node_modules/@covalent/core/esm2015/loading/directives/loading.directive.js

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
 */
import { Directive, Input } from '@angular/core';
import { ViewContainerRef, TemplateRef } from '@angular/core';
import { LoadingType, LoadingMode, LoadingStrategy } from '../loading.component';
import { TdLoadingService } from '../services/loading.service';
/**
 * Context class for variable reference
 */
export class TdLoadingContext {
    constructor() {
        this.$implicit = undefined;
        this.tdLoading = undefined;
    }
}
if (false) {
    /** @type {?} */
    TdLoadingContext.prototype.$implicit;
    /** @type {?} */
    TdLoadingContext.prototype.tdLoading;
}
// Constant for generation of the id for the next component
/** @type {?} */
let TD_LOADING_NEXT_ID = 0;
export class TdLoadingDirective {
    /**
     * @param {?} _viewContainerRef
     * @param {?} _templateRef
     * @param {?} _loadingService
     */
    constructor(_viewContainerRef, _templateRef, _loadingService) {
        this._viewContainerRef = _viewContainerRef;
        this._templateRef = _templateRef;
        this._loadingService = _loadingService;
        this._context = new TdLoadingContext();
        /**
         * tdLoadingColor?: "primary" | "accent" | "warn"
         * Sets the theme color of the loading component. Defaults to "primary"
         */
        this.color = 'primary';
    }
    /**
     * tdLoading: string
     * Name reference of the loading mask, used to register/resolve requests to the mask.
     * @param {?} name
     * @return {?}
     */
    set name(name) {
        if (!this._name) {
            if (name) {
                this._name = name;
            }
        }
    }
    /**
     * tdLoadingUntil?: any
     * If its null, undefined or false it will be used to register requests to the mask.
     * Else if its any value that can be resolved as true, it will resolve the mask.
     * [name] is optional when using [until], but can still be used to register/resolve it manually.
     * @param {?} until
     * @return {?}
     */
    set until(until) {
        if (!this._name) {
            this._name = 'td-loading-until-' + TD_LOADING_NEXT_ID++;
        }
        this._context.$implicit = this._context.tdLoading = until;
        if (!until) {
            this._loadingService.register(this._name);
        }
        else {
            this._loadingService.resolveAll(this._name);
        }
    }
    /**
     * tdLoadingType?: LoadingType or ['linear' | 'circular']
     * Sets the type of loading mask depending on value.
     * Defaults to [LoadingType.Circular | 'circular'].
     * @param {?} type
     * @return {?}
     */
    set type(type) {
        switch (type) {
            case LoadingType.Linear:
                this._type = LoadingType.Linear;
                break;
            default:
                this._type = LoadingType.Circular;
                break;
        }
    }
    /**
     * tdLoadingMode?: LoadingMode or ['determinate' | 'indeterminate']
     * Sets the mode of loading mask depending on value.
     * Defaults to [LoadingMode.Indeterminate | 'indeterminate'].
     * @param {?} mode
     * @return {?}
     */
    set mode(mode) {
        switch (mode) {
            case LoadingMode.Determinate:
                this._mode = LoadingMode.Determinate;
                break;
            default:
                this._mode = LoadingMode.Indeterminate;
                break;
        }
    }
    /**
     * tdLoadingStrategy?: LoadingStrategy or ['replace' | 'overlay']
     * Sets the strategy of loading mask depending on value.
     * Defaults to [LoadingMode.Replace | 'replace'].
     * @param {?} stategy
     * @return {?}
     */
    set strategy(stategy) {
        switch (stategy) {
            case LoadingStrategy.Overlay:
                this._strategy = LoadingStrategy.Overlay;
                break;
            default:
                this._strategy = LoadingStrategy.Replace;
                break;
        }
    }
    /**
     * Registers component in the DOM, so it will be available when calling resolve/register.
     * @return {?}
     */
    ngOnInit() {
        this._registerComponent();
    }
    /**
     * Remove component when directive is destroyed.
     * @return {?}
     */
    ngOnDestroy() {
        this._loadingService.removeComponent(this._name);
        this._loadingRef = undefined;
    }
    /**
     * Creates [TdLoadingComponent] and attaches it to this directive's [ViewContainerRef].
     * Passes this directive's [TemplateRef] to modify DOM depending on loading `strategy`.
     * @return {?}
     */
    _registerComponent() {
        if (!this._name) {
            throw new Error('Name is needed to register loading directive');
        }
        // Check if `TdLoadingComponent` has been created before trying to add one again.
        // There is a weird edge case when using `[routerLinkActive]` that calls the `ngOnInit` twice in a row
        if (!this._loadingRef) {
            this._loadingRef = this._loadingService.createComponent({
                name: this._name,
                type: this._type,
                mode: this._mode,
                color: this.color,
                strategy: this._strategy,
            }, this._viewContainerRef, this._templateRef, this._context);
        }
    }
}
TdLoadingDirective.decorators = [
    { type: Directive, args: [{
                selector: '[tdLoading]',
            },] }
];
/** @nocollapse */
TdLoadingDirective.ctorParameters = () => [
    { type: ViewContainerRef },
    { type: TemplateRef },
    { type: TdLoadingService }
];
TdLoadingDirective.propDecorators = {
    name: [{ type: Input, args: ['tdLoading',] }],
    until: [{ type: Input, args: ['tdLoadingUntil',] }],
    type: [{ type: Input, args: ['tdLoadingType',] }],
    mode: [{ type: Input, args: ['tdLoadingMode',] }],
    strategy: [{ type: Input, args: ['tdLoadingStrategy',] }],
    color: [{ type: Input, args: ['tdLoadingColor',] }]
};
if (false) {
    /** @type {?} */
    TdLoadingDirective.prototype._context;
    /** @type {?} */
    TdLoadingDirective.prototype._type;
    /** @type {?} */
    TdLoadingDirective.prototype._mode;
    /** @type {?} */
    TdLoadingDirective.prototype._strategy;
    /** @type {?} */
    TdLoadingDirective.prototype._name;
    /** @type {?} */
    TdLoadingDirective.prototype._loadingRef;
    /**
     * tdLoadingColor?: "primary" | "accent" | "warn"
     * Sets the theme color of the loading component. Defaults to "primary"
     * @type {?}
     */
    TdLoadingDirective.prototype.color;
    /** @type {?} */
    TdLoadingDirective.prototype._viewContainerRef;
    /** @type {?} */
    TdLoadingDirective.prototype._templateRef;
    /** @type {?} */
    TdLoadingDirective.prototype._loadingService;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading.directive.js","sourceRoot":"ng://@covalent/core/loading/","sources":["directives/loading.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, OnInit, OnDestroy } from '@angular/core';\nimport { ViewContainerRef, TemplateRef } from '@angular/core';\n\nimport { LoadingType, LoadingMode, LoadingStrategy, TdLoadingComponent } from '../loading.component';\nimport { TdLoadingService } from '../services/loading.service';\nimport { ILoadingRef } from '../services/loading.factory';\n\n/**\n * Context class for variable reference\n */\nexport class TdLoadingContext {\n  public $implicit: any = undefined;\n  public tdLoading: any = undefined;\n}\n\n// Constant for generation of the id for the next component\nlet TD_LOADING_NEXT_ID: number = 0;\n\n@Directive({\n  selector: '[tdLoading]',\n})\nexport class TdLoadingDirective implements OnInit, OnDestroy {\n\n  private _context: TdLoadingContext = new TdLoadingContext();\n  private _type: LoadingType;\n  private _mode: LoadingMode;\n  private _strategy: LoadingStrategy;\n  private _name: string;\n  private _loadingRef: ILoadingRef;\n\n  /**\n   * tdLoading: string\n   * Name reference of the loading mask, used to register/resolve requests to the mask.\n   */\n  @Input('tdLoading')\n  set name(name: string) {\n    if (!this._name) {\n      if (name) {\n        this._name = name;\n      }\n    }\n  }\n\n  /**\n   * tdLoadingUntil?: any\n   * If its null, undefined or false it will be used to register requests to the mask.\n   * Else if its any value that can be resolved as true, it will resolve the mask.\n   * [name] is optional when using [until], but can still be used to register/resolve it manually.\n   */\n  @Input('tdLoadingUntil')\n  set until(until: any) {\n    if (!this._name) {\n      this._name = 'td-loading-until-' + TD_LOADING_NEXT_ID++;\n    }\n    this._context.$implicit = this._context.tdLoading = until;\n    if (!until) {\n      this._loadingService.register(this._name);\n    } else {\n      this._loadingService.resolveAll(this._name);\n    }\n  }\n\n  /**\n   * tdLoadingType?: LoadingType or ['linear' | 'circular']\n   * Sets the type of loading mask depending on value.\n   * Defaults to [LoadingType.Circular | 'circular'].\n   */\n  @Input('tdLoadingType')\n  set type(type: LoadingType) {\n    switch (type) {\n      case LoadingType.Linear:\n        this._type = LoadingType.Linear;\n        break;\n      default:\n        this._type = LoadingType.Circular;\n        break;\n    }\n  }\n\n  /**\n   * tdLoadingMode?: LoadingMode or ['determinate' | 'indeterminate']\n   * Sets the mode of loading mask depending on value.\n   * Defaults to [LoadingMode.Indeterminate | 'indeterminate'].\n   */\n  @Input('tdLoadingMode')\n  set mode(mode: LoadingMode) {\n    switch (mode) {\n      case LoadingMode.Determinate:\n        this._mode = LoadingMode.Determinate;\n        break;\n      default:\n        this._mode = LoadingMode.Indeterminate;\n        break;\n    }\n  }\n\n  /**\n   * tdLoadingStrategy?: LoadingStrategy or ['replace' | 'overlay']\n   * Sets the strategy of loading mask depending on value.\n   * Defaults to [LoadingMode.Replace | 'replace'].\n   */\n  @Input('tdLoadingStrategy')\n  set strategy(stategy: LoadingStrategy) {\n    switch (stategy) {\n      case LoadingStrategy.Overlay:\n        this._strategy = LoadingStrategy.Overlay;\n        break;\n      default:\n        this._strategy = LoadingStrategy.Replace;\n        break;\n    }\n  }\n\n  /**\n   * tdLoadingColor?: \"primary\" | \"accent\" | \"warn\"\n   * Sets the theme color of the loading component. Defaults to \"primary\"\n   */\n  @Input('tdLoadingColor') color: 'primary' | 'accent' | 'warn' = 'primary';\n\n  constructor(private _viewContainerRef: ViewContainerRef,\n              private _templateRef: TemplateRef<TdLoadingContext>,\n              private _loadingService: TdLoadingService) {}\n\n  /**\n   * Registers component in the DOM, so it will be available when calling resolve/register.\n   */\n  ngOnInit(): void {\n    this._registerComponent();\n  }\n\n  /**\n   * Remove component when directive is destroyed.\n   */\n  ngOnDestroy(): void {\n    this._loadingService.removeComponent(this._name);\n    this._loadingRef = undefined;\n  }\n\n  /**\n   * Creates [TdLoadingComponent] and attaches it to this directive's [ViewContainerRef].\n   * Passes this directive's [TemplateRef] to modify DOM depending on loading `strategy`.\n   */\n  private _registerComponent(): void {\n    if (!this._name) {\n      throw new Error('Name is needed to register loading directive');\n    }\n    // Check if `TdLoadingComponent` has been created before trying to add one again.\n    // There is a weird edge case when using `[routerLinkActive]` that calls the `ngOnInit` twice in a row\n    if (!this._loadingRef) {\n      this._loadingRef = this._loadingService.createComponent({\n        name: this._name,\n        type: this._type,\n        mode: this._mode,\n        color: this.color,\n        strategy: this._strategy,\n      }, this._viewContainerRef, this._templateRef, this._context);\n    }\n  }\n}\n"]}