| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc |
| */ |
| import { Component, ChangeDetectorRef, ElementRef } from '@angular/core'; |
| import { Subject } from 'rxjs'; |
| /** @enum {string} */ |
| const LoadingType = { |
| Circular: 'circular', |
| Linear: 'linear', |
| }; |
| export { LoadingType }; |
| /** @enum {string} */ |
| const LoadingMode = { |
| Determinate: 'determinate', |
| Indeterminate: 'indeterminate', |
| }; |
| export { LoadingMode }; |
| /** @enum {string} */ |
| const LoadingStrategy = { |
| Overlay: 'overlay', |
| Replace: 'replace', |
| }; |
| export { LoadingStrategy }; |
| /** @enum {string} */ |
| const LoadingStyle = { |
| FullScreen: 'fullscreen', |
| Overlay: 'overlay', |
| None: 'none', |
| }; |
| export { LoadingStyle }; |
| import { tdFadeInOutAnimation } from '@covalent/core/common'; |
| /** @type {?} */ |
| export const TD_CIRCLE_DIAMETER = 100; |
| export class TdLoadingComponent { |
| /** |
| * @param {?} _elementRef |
| * @param {?} _changeDetectorRef |
| */ |
| constructor(_elementRef, _changeDetectorRef) { |
| this._elementRef = _elementRef; |
| this._changeDetectorRef = _changeDetectorRef; |
| this._animationIn = new Subject(); |
| this._animationOut = new Subject(); |
| this._mode = LoadingMode.Indeterminate; |
| this._defaultMode = LoadingMode.Indeterminate; |
| this._value = 0; |
| this._circleDiameter = TD_CIRCLE_DIAMETER; |
| /** |
| * Flag for animation |
| */ |
| this.animation = false; |
| this.style = LoadingStyle.None; |
| /** |
| * type: LoadingType |
| * Sets type of [TdLoadingComponent] rendered. |
| */ |
| this.type = LoadingType.Circular; |
| /** |
| * color: primary' | 'accent' | 'warn' |
| * Sets theme color of [TdLoadingComponent] rendered. |
| */ |
| this.color = 'primary'; |
| } |
| /** |
| * Sets mode of [TdLoadingComponent] to LoadingMode.Determinate or LoadingMode.Indeterminate |
| * @param {?} mode |
| * @return {?} |
| */ |
| set mode(mode) { |
| this._defaultMode = mode; |
| } |
| /** |
| * @return {?} |
| */ |
| get mode() { |
| return this._mode; |
| } |
| /** |
| * Sets value of [TdLoadingComponent] if mode is 'LoadingMode.Determinate' |
| * @param {?} value |
| * @return {?} |
| */ |
| set value(value) { |
| this._value = value; |
| // Check for changes for `OnPush` change detection |
| this._changeDetectorRef.markForCheck(); |
| } |
| /** |
| * @return {?} |
| */ |
| get value() { |
| return this._value; |
| } |
| /** |
| * @return {?} |
| */ |
| ngDoCheck() { |
| // When overlay is used and the host width has a value greater than 1px |
| // set the circle diameter when possible incase the loading component was rendered in a hidden state |
| if (this.isOverlay() && this._hostHeight() > 1) { |
| if (this.animation) { |
| this._setCircleDiameter(); |
| this._changeDetectorRef.markForCheck(); |
| } |
| } |
| } |
| /** |
| * @return {?} |
| */ |
| getHeight() { |
| // Ignore height if style is `overlay` or `fullscreen`. |
| // Add height if child elements have a height and style is `none`, else return default height. |
| if (this.isOverlay() || this.isFullScreen()) { |
| return undefined; |
| } |
| else { |
| return this.height ? `${this.height}px` : '150px'; |
| } |
| } |
| /** |
| * @return {?} |
| */ |
| getCircleDiameter() { |
| return this._circleDiameter; |
| } |
| /** |
| * @return {?} |
| */ |
| getCircleStrokeWidth() { |
| // we calculate the stroke width by setting it as 10% of its diameter |
| /** @type {?} */ |
| let strokeWidth = this.getCircleDiameter() / 10; |
| return Math.abs(strokeWidth); |
| } |
| /** |
| * @return {?} |
| */ |
| isCircular() { |
| return this.type === LoadingType.Circular; |
| } |
| /** |
| * @return {?} |
| */ |
| isLinear() { |
| return this.type === LoadingType.Linear; |
| } |
| /** |
| * @return {?} |
| */ |
| isFullScreen() { |
| return this.style === LoadingStyle.FullScreen; |
| } |
| /** |
| * @return {?} |
| */ |
| isOverlay() { |
| return this.style === LoadingStyle.Overlay; |
| } |
| /** |
| * @param {?} event |
| * @return {?} |
| */ |
| animationComplete(event) { |
| // Check to see if its "in" or "out" animation to execute the proper callback |
| if (!event.fromState) { |
| this.inAnimationCompleted(); |
| } |
| else { |
| this.outAnimationCompleted(); |
| } |
| } |
| /** |
| * @return {?} |
| */ |
| inAnimationCompleted() { |
| this._animationIn.next(undefined); |
| } |
| /** |
| * @return {?} |
| */ |
| outAnimationCompleted() { |
| /* little hack to reset the loader value and animation before removing it from DOM |
| * else, the loader will appear with prev value when its registered again |
| * and will do an animation going prev value to 0. |
| */ |
| this.value = 0; |
| // Check for changes for `OnPush` change detection |
| this._changeDetectorRef.markForCheck(); |
| this._animationOut.next(undefined); |
| } |
| /** |
| * Starts in animation and returns an observable for completition event. |
| * @return {?} |
| */ |
| startInAnimation() { |
| /* need to switch back to the selected mode, so we have saved it in another variable |
| * and then recover it. (issue with protractor) |
| */ |
| this._mode = this._defaultMode; |
| // Set values before the animations starts |
| this._setCircleDiameter(); |
| // Check for changes for `OnPush` change detection |
| this.animation = true; |
| this._changeDetectorRef.markForCheck(); |
| return this._animationIn.asObservable(); |
| } |
| /** |
| * Starts out animation and returns an observable for completition event. |
| * @return {?} |
| */ |
| startOutAnimation() { |
| this.animation = false; |
| /* need to switch back and forth from determinate/indeterminate so the setInterval() |
| * inside mat-progress-spinner stops and protractor doesnt timeout waiting to sync. |
| */ |
| this._mode = LoadingMode.Determinate; |
| // Check for changes for `OnPush` change detection |
| this._changeDetectorRef.markForCheck(); |
| return this._animationOut.asObservable(); |
| } |
| /** |
| * Calculate the proper diameter for the circle and set it |
| * @return {?} |
| */ |
| _setCircleDiameter() { |
| // we set a default diameter of 100 since this is the default in material |
| /** @type {?} */ |
| let diameter = TD_CIRCLE_DIAMETER; |
| // if height is provided, then we take that as diameter |
| if (this.height) { |
| diameter = this.height; |
| // else if its not provided, then we take the host height |
| } |
| else if (this.height === undefined) { |
| diameter = this._hostHeight(); |
| } |
| // if the diameter is over TD_CIRCLE_DIAMETER, we set TD_CIRCLE_DIAMETER |
| if (!!diameter && diameter <= TD_CIRCLE_DIAMETER) { |
| this._circleDiameter = Math.floor(diameter); |
| } |
| else { |
| this._circleDiameter = TD_CIRCLE_DIAMETER; |
| } |
| } |
| /** |
| * Returns the host height of the loading component |
| * @return {?} |
| */ |
| _hostHeight() { |
| if ((/** @type {?} */ (this._elementRef.nativeElement))) { |
| return ((/** @type {?} */ (this._elementRef.nativeElement))).getBoundingClientRect().height; |
| } |
| return 0; |
| } |
| } |
| TdLoadingComponent.decorators = [ |
| { type: Component, args: [{ |
| selector: 'td-loading', |
| template: "<div class=\"td-loading-wrapper\"\n [style.min-height]=\"getHeight()\"\n [class.td-overlay-circular]=\"(isOverlay() || isFullScreen()) && !isLinear()\"\n [class.td-overlay]=\"isOverlay() || isFullScreen()\" \n [class.td-fullscreen]=\"isFullScreen()\">\n <div [@tdFadeInOut]=\"animation\"\n (@tdFadeInOut.done)=\"animationComplete($event)\"\n [style.min-height]=\"getHeight()\"\n class=\"td-loading\">\n <mat-progress-spinner *ngIf=\"isCircular()\" \n [mode]=\"mode\"\n [value]=\"value\" \n [color]=\"color\" \n [diameter]=\"getCircleDiameter()\"\n [strokeWidth]=\"getCircleStrokeWidth()\">\n </mat-progress-spinner>\n <mat-progress-bar *ngIf=\"isLinear()\" \n [mode]=\"mode\"\n [value]=\"value\"\n [color]=\"color\">\n </mat-progress-bar>\n </div>\n <ng-template [cdkPortalOutlet]=\"content\"></ng-template>\n</div>", |
| animations: [ |
| tdFadeInOutAnimation, |
| ], |
| styles: [".td-loading-wrapper{position:relative;display:block}.td-loading-wrapper.td-fullscreen{position:inherit}.td-loading-wrapper .td-loading{-webkit-box-sizing:border-box;box-sizing:border-box;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:center;align-content:center;max-width:100%;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;-webkit-box-flex:1;-ms-flex:1;flex:1}.td-loading-wrapper.td-overlay .td-loading{position:absolute;margin:0;top:0;left:0;right:0;z-index:1000}.td-loading-wrapper.td-overlay .td-loading mat-progress-bar{position:absolute;top:0;left:0;right:0}.td-loading-wrapper.td-overlay-circular .td-loading{bottom:0}"] |
| }] } |
| ]; |
| /** @nocollapse */ |
| TdLoadingComponent.ctorParameters = () => [ |
| { type: ElementRef }, |
| { type: ChangeDetectorRef } |
| ]; |
| if (false) { |
| /** @type {?} */ |
| TdLoadingComponent.prototype._animationIn; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._animationOut; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._mode; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._defaultMode; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._value; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._circleDiameter; |
| /** |
| * Flag for animation |
| * @type {?} |
| */ |
| TdLoadingComponent.prototype.animation; |
| /** |
| * Content injected into loading component. |
| * @type {?} |
| */ |
| TdLoadingComponent.prototype.content; |
| /** @type {?} */ |
| TdLoadingComponent.prototype.style; |
| /** |
| * height: number |
| * Sets height of [TdLoadingComponent]. |
| * @type {?} |
| */ |
| TdLoadingComponent.prototype.height; |
| /** |
| * type: LoadingType |
| * Sets type of [TdLoadingComponent] rendered. |
| * @type {?} |
| */ |
| TdLoadingComponent.prototype.type; |
| /** |
| * color: primary' | 'accent' | 'warn' |
| * Sets theme color of [TdLoadingComponent] rendered. |
| * @type {?} |
| */ |
| TdLoadingComponent.prototype.color; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._elementRef; |
| /** @type {?} */ |
| TdLoadingComponent.prototype._changeDetectorRef; |
| } |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading.component.js","sourceRoot":"ng://@covalent/core/loading/","sources":["loading.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ViewChild, TemplateRef, ChangeDetectorRef, ChangeDetectionStrategy, ElementRef, DoCheck } from '@angular/core';\nimport { AnimationEvent } from '@angular/animations';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { Observable, Subject } from 'rxjs';\n\nexport enum LoadingType {\n  Circular = 'circular',\n  Linear = 'linear',\n}\n\nexport enum LoadingMode {\n  Determinate = 'determinate',\n  Indeterminate = 'indeterminate',\n}\n\nexport enum LoadingStrategy {\n  Overlay = 'overlay',\n  Replace = 'replace',\n}\n\nexport enum LoadingStyle {\n  FullScreen = 'fullscreen',\n  Overlay = 'overlay',\n  None = 'none',\n}\n\nimport { tdFadeInOutAnimation } from '@covalent/core/common';\n\nexport const TD_CIRCLE_DIAMETER: number = 100;\n\n@Component({\n  selector: 'td-loading',\n  styleUrls: ['./loading.component.scss' ],\n  templateUrl: './loading.component.html',\n  animations: [\n    tdFadeInOutAnimation,\n  ],\n})\nexport class TdLoadingComponent implements DoCheck {\n\n  private _animationIn: Subject<any> = new Subject<any>();\n  private _animationOut: Subject<any> = new Subject<any>();\n  private _mode: LoadingMode = LoadingMode.Indeterminate;\n  private _defaultMode: LoadingMode = LoadingMode.Indeterminate;\n  private _value: number = 0;\n  private _circleDiameter: number = TD_CIRCLE_DIAMETER;\n\n  /**\n   * Flag for animation\n   */\n  animation: boolean = false;\n\n  /**\n   * Content injected into loading component.\n   */\n  content: TemplatePortal<any>;\n\n  /**\n   * Sets mode of [TdLoadingComponent] to LoadingMode.Determinate or LoadingMode.Indeterminate\n   */\n  set mode(mode: LoadingMode) {\n    this._defaultMode = mode;\n  }\n  get mode(): LoadingMode {\n    return this._mode;\n  }\n\n  /**\n   * Sets value of [TdLoadingComponent] if mode is 'LoadingMode.Determinate'\n   */\n  set value(value: number) {\n    this._value = value;\n    // Check for changes for `OnPush` change detection\n    this._changeDetectorRef.markForCheck();\n  }\n  get value(): number {\n    return this._value;\n  }\n\n  style: LoadingStyle = LoadingStyle.None;\n\n  /**\n   * height: number\n   * Sets height of [TdLoadingComponent].\n   */\n  height: number;\n\n  /**\n   * type: LoadingType\n   * Sets type of [TdLoadingComponent] rendered.\n   */\n  type: LoadingType = LoadingType.Circular;\n\n  /**\n   * color: primary' | 'accent' | 'warn'\n   * Sets theme color of [TdLoadingComponent] rendered.\n   */\n  color: 'primary' | 'accent' | 'warn' = 'primary';\n\n  constructor(private _elementRef: ElementRef,\n              private _changeDetectorRef: ChangeDetectorRef) {}\n\n  ngDoCheck(): void {\n    // When overlay is used and the host width has a value greater than 1px\n    // set the circle diameter when possible incase the loading component was rendered in a hidden state\n    if (this.isOverlay() && this._hostHeight() > 1) {\n      if (this.animation) {\n        this._setCircleDiameter();\n        this._changeDetectorRef.markForCheck();\n      }\n    }\n  }\n\n  getHeight(): string {\n    // Ignore height if style is `overlay` or `fullscreen`.\n    // Add height if child elements have a height and style is `none`, else return default height.\n    if (this.isOverlay() || this.isFullScreen()) {\n      return undefined;\n    } else {\n      return this.height ? `${this.height}px` : '150px';\n    }\n  }\n\n  getCircleDiameter(): number {\n    return this._circleDiameter;\n  }\n\n  getCircleStrokeWidth(): number {\n    // we calculate the stroke width by setting it as 10% of its diameter\n    let strokeWidth: number = this.getCircleDiameter() / 10;\n    return Math.abs(strokeWidth);\n  }\n\n  isCircular(): boolean {\n    return this.type === LoadingType.Circular;\n  }\n\n  isLinear(): boolean {\n    return this.type === LoadingType.Linear;\n  }\n\n  isFullScreen(): boolean {\n    return this.style === LoadingStyle.FullScreen;\n  }\n\n  isOverlay(): boolean {\n    return this.style === LoadingStyle.Overlay;\n  }\n\n  animationComplete(event: AnimationEvent): void {\n    // Check to see if its \"in\" or \"out\" animation to execute the proper callback\n    if (!event.fromState) {\n      this.inAnimationCompleted();\n    } else {\n      this.outAnimationCompleted();\n    }\n  }\n\n  inAnimationCompleted(): void {\n    this._animationIn.next(undefined);\n  }\n\n  outAnimationCompleted(): void {\n   /* little hack to reset the loader value and animation before removing it from DOM\n    * else, the loader will appear with prev value when its registered again\n    * and will do an animation going prev value to 0.\n    */\n    this.value = 0;\n    // Check for changes for `OnPush` change detection\n    this._changeDetectorRef.markForCheck();\n    this._animationOut.next(undefined);\n  }\n\n  /**\n   * Starts in animation and returns an observable for completition event.\n   */\n  startInAnimation(): Observable<any> {\n    /* need to switch back to the selected mode, so we have saved it in another variable\n    *  and then recover it. (issue with protractor)\n    */\n    this._mode = this._defaultMode;\n    // Set values before the animations starts\n    this._setCircleDiameter();\n    // Check for changes for `OnPush` change detection\n    this.animation = true;\n    this._changeDetectorRef.markForCheck();\n    return this._animationIn.asObservable();\n  }\n\n  /**\n   * Starts out animation and returns an observable for completition event.\n   */\n  startOutAnimation(): Observable<any> {\n    this.animation = false;\n    /* need to switch back and forth from determinate/indeterminate so the setInterval()\n    * inside mat-progress-spinner stops and protractor doesnt timeout waiting to sync.\n    */\n    this._mode = LoadingMode.Determinate;\n    // Check for changes for `OnPush` change detection\n    this._changeDetectorRef.markForCheck();\n    return this._animationOut.asObservable();\n  }\n\n  /**\n   * Calculate the proper diameter for the circle and set it\n   */\n  private _setCircleDiameter(): void {\n    // we set a default diameter of 100 since this is the default in material\n    let diameter: number = TD_CIRCLE_DIAMETER;\n    // if height is provided, then we take that as diameter\n    if (this.height) {\n      diameter = this.height;\n      // else if its not provided, then we take the host height\n    } else if (this.height === undefined) {\n      diameter = this._hostHeight();\n    }\n    // if the diameter is over TD_CIRCLE_DIAMETER, we set TD_CIRCLE_DIAMETER\n    if (!!diameter && diameter <= TD_CIRCLE_DIAMETER) {\n      this._circleDiameter = Math.floor(diameter);\n    } else {\n      this._circleDiameter = TD_CIRCLE_DIAMETER;\n    }\n  }\n\n  /**\n   * Returns the host height of the loading component\n   */\n  private _hostHeight(): number {\n    if (<HTMLElement>this._elementRef.nativeElement) {\n      return (<HTMLElement>this._elementRef.nativeElement).getBoundingClientRect().height;\n    }\n    return 0;\n  }\n}\n"]} |
