node_modules/@covalent/core/esm5/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
 */
var /**
 * Context class for variable reference
 */
TdLoadingContext = /** @class */ (function () {
    function TdLoadingContext() {
        this.$implicit = undefined;
        this.tdLoading = undefined;
    }
    return TdLoadingContext;
}());
/**
 * Context class for variable reference
 */
export { TdLoadingContext };
if (false) {
    /** @type {?} */
    TdLoadingContext.prototype.$implicit;
    /** @type {?} */
    TdLoadingContext.prototype.tdLoading;
}
// Constant for generation of the id for the next component
/** @type {?} */
var TD_LOADING_NEXT_ID = 0;
var TdLoadingDirective = /** @class */ (function () {
    function TdLoadingDirective(_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';
    }
    Object.defineProperty(TdLoadingDirective.prototype, "name", {
        /**
         * tdLoading: string
         * Name reference of the loading mask, used to register/resolve requests to the mask.
         */
        set: /**
         * tdLoading: string
         * Name reference of the loading mask, used to register/resolve requests to the mask.
         * @param {?} name
         * @return {?}
         */
        function (name) {
            if (!this._name) {
                if (name) {
                    this._name = name;
                }
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(TdLoadingDirective.prototype, "until", {
        /**
         * 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.
         */
        set: /**
         * 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 {?}
         */
        function (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);
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(TdLoadingDirective.prototype, "type", {
        /**
         * tdLoadingType?: LoadingType or ['linear' | 'circular']
         * Sets the type of loading mask depending on value.
         * Defaults to [LoadingType.Circular | 'circular'].
         */
        set: /**
         * tdLoadingType?: LoadingType or ['linear' | 'circular']
         * Sets the type of loading mask depending on value.
         * Defaults to [LoadingType.Circular | 'circular'].
         * @param {?} type
         * @return {?}
         */
        function (type) {
            switch (type) {
                case LoadingType.Linear:
                    this._type = LoadingType.Linear;
                    break;
                default:
                    this._type = LoadingType.Circular;
                    break;
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(TdLoadingDirective.prototype, "mode", {
        /**
         * tdLoadingMode?: LoadingMode or ['determinate' | 'indeterminate']
         * Sets the mode of loading mask depending on value.
         * Defaults to [LoadingMode.Indeterminate | 'indeterminate'].
         */
        set: /**
         * tdLoadingMode?: LoadingMode or ['determinate' | 'indeterminate']
         * Sets the mode of loading mask depending on value.
         * Defaults to [LoadingMode.Indeterminate | 'indeterminate'].
         * @param {?} mode
         * @return {?}
         */
        function (mode) {
            switch (mode) {
                case LoadingMode.Determinate:
                    this._mode = LoadingMode.Determinate;
                    break;
                default:
                    this._mode = LoadingMode.Indeterminate;
                    break;
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(TdLoadingDirective.prototype, "strategy", {
        /**
         * tdLoadingStrategy?: LoadingStrategy or ['replace' | 'overlay']
         * Sets the strategy of loading mask depending on value.
         * Defaults to [LoadingMode.Replace | 'replace'].
         */
        set: /**
         * tdLoadingStrategy?: LoadingStrategy or ['replace' | 'overlay']
         * Sets the strategy of loading mask depending on value.
         * Defaults to [LoadingMode.Replace | 'replace'].
         * @param {?} stategy
         * @return {?}
         */
        function (stategy) {
            switch (stategy) {
                case LoadingStrategy.Overlay:
                    this._strategy = LoadingStrategy.Overlay;
                    break;
                default:
                    this._strategy = LoadingStrategy.Replace;
                    break;
            }
        },
        enumerable: true,
        configurable: true
    });
    /**
     * Registers component in the DOM, so it will be available when calling resolve/register.
     */
    /**
     * Registers component in the DOM, so it will be available when calling resolve/register.
     * @return {?}
     */
    TdLoadingDirective.prototype.ngOnInit = /**
     * Registers component in the DOM, so it will be available when calling resolve/register.
     * @return {?}
     */
    function () {
        this._registerComponent();
    };
    /**
     * Remove component when directive is destroyed.
     */
    /**
     * Remove component when directive is destroyed.
     * @return {?}
     */
    TdLoadingDirective.prototype.ngOnDestroy = /**
     * Remove component when directive is destroyed.
     * @return {?}
     */
    function () {
        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`.
     */
    /**
     * Creates [TdLoadingComponent] and attaches it to this directive's [ViewContainerRef].
     * Passes this directive's [TemplateRef] to modify DOM depending on loading `strategy`.
     * @return {?}
     */
    TdLoadingDirective.prototype._registerComponent = /**
     * Creates [TdLoadingComponent] and attaches it to this directive's [ViewContainerRef].
     * Passes this directive's [TemplateRef] to modify DOM depending on loading `strategy`.
     * @return {?}
     */
    function () {
        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 = function () { return [
        { 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',] }]
    };
    return TdLoadingDirective;
}());
export { TdLoadingDirective };
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"]}