@ciri/ngx-countdown
Version:
An angular countdown component.
324 lines • 20 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/countdown.component.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output, TemplateRef } from '@angular/core';
import { interval } from 'rxjs';
import { animationFrame } from 'rxjs/internal/scheduler/animationFrame';
import { isSameSecond, parseFormat, parseTimeData } from './utils';
/**
* @record
*/
function CountdownData() { }
if (false) {
/** @type {?} */
CountdownData.prototype.remain;
/** @type {?} */
CountdownData.prototype.formattedTime;
/** @type {?} */
CountdownData.prototype.fragments;
}
/** @enum {number} */
var CountdownState = {
/** 暂停状态 */
paused: 0,
/** 运行状态 */
playing: 1,
/** 完成状态 */
finished: 2,
};
export { CountdownState };
CountdownState[CountdownState.paused] = 'paused';
CountdownState[CountdownState.playing] = 'playing';
CountdownState[CountdownState.finished] = 'finished';
/**
* 所有组件实例使用同一个 interval 流，以免实例多了后造成卡顿
* @type {?}
*/
var instances = [];
/** @type {?} */
var counter$ = interval(0, animationFrame);
/** @type {?} */
var counterSub;
/**
* @return {?}
*/
function setupCounter() {
destroyCounter();
counterSub = counter$.subscribe((/**
* @return {?}
*/
function () {
for (var i = 0; i < instances.length; i++) {
/** @type {?} */
var inst = instances[i];
if (inst.state !== CountdownState.playing) {
continue;
}
if (inst.remain <= 0) {
inst.state = CountdownState.finished;
inst.cdr.detectChanges();
inst.finish.emit();
continue;
}
/** @type {?} */
var remain = Math.max(inst.endTime - Date.now(), 0);
if (!inst.millisecond) {
if (!isSameSecond(remain, inst.remain) || remain === 0) {
inst.remain = remain;
inst.tick.emit(inst.remain);
}
}
else {
inst.remain = remain;
inst.tick.emit(inst.remain);
}
inst.cdr.detectChanges();
}
}));
}
/**
* @return {?}
*/
function destroyCounter() {
counterSub && counterSub.unsubscribe();
}
/**
* 倒计时组件
*/
var CountdownComponent = /** @class */ (function () {
function CountdownComponent(cdr) {
this.cdr = cdr;
/**
* 格式
*/
this.format = 'HH:mm:ss';
/**
* 是否自动开始
*/
this.autoStart = true;
/**
* 是否开启毫秒级渲染
*/
this.millisecond = false;
/**
* 倒计时完毕时触发
*/
this.finish = new EventEmitter();
/**
* 每倒计时一次都触发
*/
this.tick = new EventEmitter();
this.state = CountdownState.paused;
this._time = 60000;
}
Object.defineProperty(CountdownComponent.prototype, "time", {
get: /**
* @return {?}
*/
function () {
return this._time;
},
/** 总毫秒数 */
set: /**
* 总毫秒数
* @param {?} value
* @return {?}
*/
function (value) {
this._time = Math.max(value, 0);
this.reset();
},
enumerable: true,
configurable: true
});
Object.defineProperty(CountdownComponent.prototype, "data", {
get: /**
* @return {?}
*/
function () {
/** @type {?} */
var noMillisecond = this.format.indexOf('S') === -1;
/** @type {?} */
var isPlaying = this.state === CountdownState.playing
// 即使 format 中没有设置毫秒，程序计算时候也会将毫秒计算进去，导致运行时秒数看上去总是小 1
// 此处在渲染时候手动 +1 秒，以追求视觉统一
;
// 即使 format 中没有设置毫秒，程序计算时候也会将毫秒计算进去，导致运行时秒数看上去总是小 1
// 此处在渲染时候手动 +1 秒，以追求视觉统一
/** @type {?} */
var timeData = parseTimeData(this.remain + (noMillisecond && isPlaying ? 1000 : 0));
/** @type {?} */
var formattedTime = parseFormat(this.format, timeData);
return {
formattedTime: formattedTime,
remain: this.remain,
fragments: formattedTime.split(':')
};
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
CountdownComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
instances.push(this);
if (instances.length === 1) {
setupCounter();
}
};
/**
* @return {?}
*/
CountdownComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.pause();
/** @type {?} */
var index = instances.indexOf(this);
if (index !== -1) {
instances.splice(index, 1);
}
if (instances.length === 0) {
destroyCounter();
}
};
/**
* 继续倒计时
*/
/**
* 继续倒计时
* @return {?}
*/
CountdownComponent.prototype.start = /**
* 继续倒计时
* @return {?}
*/
function () {
if (this.state === CountdownState.playing) {
return;
}
if (this.state === CountdownState.finished) {
this.remain = this.time;
}
this.endTime = Date.now() + this.remain;
this.state = CountdownState.playing;
};
/**
* 暂停倒计时
*/
/**
* 暂停倒计时
* @return {?}
*/
CountdownComponent.prototype.pause = /**
* 暂停倒计时
* @return {?}
*/
function () {
this.state = CountdownState.paused;
};
/**
* 重置倒计时
*/
/**
* 重置倒计时
* @return {?}
*/
CountdownComponent.prototype.reset = /**
* 重置倒计时
* @return {?}
*/
function () {
this.pause();
this.remain = this.time;
this.cdr.detectChanges();
if (this.autoStart) {
this.start();
}
};
CountdownComponent.decorators = [
{ type: Component, args: [{
selector: 'ngx-countdown',
template: "<ng-container *ngIf=\"!render\">{{ data.formattedTime }}</ng-container>\n<ng-container *ngTemplateOutlet=\"render; context: { $implicit: data }\"></ng-container>\n",
changeDetection: ChangeDetectionStrategy.OnPush
}] }
];
/** @nocollapse */
CountdownComponent.ctorParameters = function () { return [
{ type: ChangeDetectorRef }
]; };
CountdownComponent.propDecorators = {
format: [{ type: Input }],
autoStart: [{ type: Input }],
millisecond: [{ type: Input }],
render: [{ type: Input }],
time: [{ type: Input }],
finish: [{ type: Output }],
tick: [{ type: Output }]
};
return CountdownComponent;
}());
export { CountdownComponent };
if (false) {
/**
* 格式
* @type {?}
*/
CountdownComponent.prototype.format;
/**
* 是否自动开始
* @type {?}
*/
CountdownComponent.prototype.autoStart;
/**
* 是否开启毫秒级渲染
* @type {?}
*/
CountdownComponent.prototype.millisecond;
/**
* 自定义模版
* @type {?}
*/
CountdownComponent.prototype.render;
/**
* 倒计时完毕时触发
* @type {?}
*/
CountdownComponent.prototype.finish;
/**
* 每倒计时一次都触发
* @type {?}
*/
CountdownComponent.prototype.tick;
/** @type {?} */
CountdownComponent.prototype.state;
/**
* @type {?}
* @private
*/
CountdownComponent.prototype._time;
/**
* 剩余毫秒数
* @type {?}
* @private
*/
CountdownComponent.prototype.remain;
/**
* @type {?}
* @private
*/
CountdownComponent.prototype.endTime;
/**
* @type {?}
* @private
*/
CountdownComponent.prototype.cdr;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"countdown.component.js","sourceRoot":"ng://@ciri/ngx-countdown/","sources":["lib/countdown.component.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,KAAK,EAGL,MAAM,EACN,WAAW,EACZ,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,QAAQ,EAAgB,MAAM,MAAM,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AACvE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;;;;AAElE,4BAIC;;;IAHC,+BAAc;;IACd,sCAAqB;;IACrB,kCAAgB;;;AAElB,IAAY,cAAc;IACxB,WAAW;IACX,MAAM,GAAA;IACN,WAAW;IACX,OAAO,GAAA;IACP,WAAW;IACX,QAAQ,GAAA;EACT;;;;;;;;;IAKK,SAAS,GAAG,EAAE;;IACd,QAAQ,GAAG,QAAQ,CAAC,CAAC,EAAE,cAAc,CAAC;;IACxC,UAAwB;;;;AAE5B,SAAS,YAAY;IACnB,cAAc,EAAE,CAAA;IAChB,UAAU,GAAG,QAAQ,CAAC,SAAS;;;IAAC;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;gBACnC,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC;YAEzB,IAAI,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,OAAO,EAAE;gBACzC,SAAQ;aACT;YAED,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE;gBACpB,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,QAAQ,CAAA;gBACpC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAA;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;gBAClB,SAAQ;aACT;;gBAEK,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAErD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACrB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,KAAK,CAAC,EAAE;oBACtD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;oBACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;iBAC5B;aACF;iBAAM;gBACL,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;gBACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;aAC5B;YAED,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAA;SACzB;IACH,CAAC,EAAC,CAAA;AACJ,CAAC;;;;AACD,SAAS,cAAc;IACrB,UAAU,IAAI,UAAU,CAAC,WAAW,EAAE,CAAA;AACxC,CAAC;;;;AAKD;IAkDE,4BAAoB,GAAsB;QAAtB,QAAG,GAAH,GAAG,CAAmB;;;;QA3CjC,WAAM,GAAW,UAAU,CAAA;;;;QAE3B,cAAS,GAAY,IAAI,CAAA;;;;QAEzB,gBAAW,GAAY,KAAK,CAAA;;;;QAc3B,WAAM,GAAG,IAAI,YAAY,EAAO,CAAA;;;;QAEhC,SAAI,GAAG,IAAI,YAAY,EAAU,CAAA;QAE3C,UAAK,GAAmB,cAAc,CAAC,MAAM,CAAA;QAgBrC,UAAK,GAAW,KAAK,CAAA;IAKgB,CAAC;IAnC9C,sBACI,oCAAI;;;;QAIR;YACE,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;QARD,WAAW;;;;;;QACX,UACS,KAAa;YACpB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;YAC/B,IAAI,CAAC,KAAK,EAAE,CAAA;QACd,CAAC;;;OAAA;IAWD,sBAAI,oCAAI;;;;QAAR;;gBACQ,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;;gBACnD,SAAS,GAAG,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,OAAO;YAEnD,oDAAoD;YACpD,yBAAyB;;;;;gBACnB,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,aAAa,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;gBAC/E,aAAa,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC;YACxD,OAAO;gBACL,aAAa,eAAA;gBACb,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,SAAS,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC;aACpC,CAAA;QACH,CAAC;;;OAAA;;;;IASD,qCAAQ;;;IAAR;QACE,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACpB,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,YAAY,EAAE,CAAA;SACf;IACH,CAAC;;;;IAED,wCAAW;;;IAAX;QACE,IAAI,CAAC,KAAK,EAAE,CAAA;;YACN,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;QACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YAChB,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;SAC3B;QACD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,cAAc,EAAE,CAAA;SACjB;IACH,CAAC;IAED;;OAEG;;;;;IACH,kCAAK;;;;IAAL;QACE,IAAI,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,OAAO,EAAE;YACzC,OAAM;SACP;QAED,IAAI,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,QAAQ,EAAE;YAC1C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAA;SACxB;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,CAAA;QACvC,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,OAAO,CAAA;IACrC,CAAC;IAED;;OAEG;;;;;IACH,kCAAK;;;;IAAL;QACE,IAAI,CAAC,KAAK,GAAG,cAAc,CAAC,MAAM,CAAA;IACpC,CAAC;IAED;;OAEG;;;;;IACH,kCAAK;;;;IAAL;QACE,IAAI,CAAC,KAAK,EAAE,CAAA;QACZ,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAA;QACvB,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAA;QAExB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,KAAK,EAAE,CAAA;SACb;IACH,CAAC;;gBAxGF,SAAS,SAAC;oBACT,QAAQ,EAAE,eAAe;oBACzB,+KAAyC;oBACzC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAChD;;;;gBA9EC,iBAAiB;;;yBAiFhB,KAAK;4BAEL,KAAK;8BAEL,KAAK;yBAEL,KAAK;uBAEL,KAAK;yBAUL,MAAM;uBAEN,MAAM;;IA8ET,yBAAC;CAAA,AAzGD,IAyGC;SApGY,kBAAkB;;;;;;IAE7B,oCAAoC;;;;;IAEpC,uCAAkC;;;;;IAElC,yCAAqC;;;;;IAErC,oCAAiC;;;;;IAYjC,oCAA0C;;;;;IAE1C,kCAA2C;;IAE3C,mCAA6C;;;;;IAgB7C,mCAA6B;;;;;;IAE7B,oCAAsB;;;;;IACtB,qCAAuB;;;;;IAEX,iCAA8B","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  TemplateRef\n} from '@angular/core'\nimport { interval, Subscription } from 'rxjs'\nimport { animationFrame } from 'rxjs/internal/scheduler/animationFrame'\nimport { isSameSecond, parseFormat, parseTimeData } from './utils'\n\ninterface CountdownData {\n  remain: number\n  formattedTime: string\n  fragments: any[]\n}\nexport enum CountdownState {\n  /** 暂停状态 */\n  paused,\n  /** 运行状态 */\n  playing,\n  /** 完成状态 */\n  finished\n}\n\n/**\n * 所有组件实例使用同一个 interval 流，以免实例多了后造成卡顿\n */\nconst instances = []\nconst counter$ = interval(0, animationFrame)\nlet counterSub: Subscription\n\nfunction setupCounter() {\n  destroyCounter()\n  counterSub = counter$.subscribe(() => {\n    for (let i = 0; i < instances.length; i++) {\n      const inst = instances[i]\n\n      if (inst.state !== CountdownState.playing) {\n        continue\n      }\n\n      if (inst.remain <= 0) {\n        inst.state = CountdownState.finished\n        inst.cdr.detectChanges()\n        inst.finish.emit()\n        continue\n      }\n\n      const remain = Math.max(inst.endTime - Date.now(), 0)\n\n      if (!inst.millisecond) {\n        if (!isSameSecond(remain, inst.remain) || remain === 0) {\n          inst.remain = remain\n          inst.tick.emit(inst.remain)\n        }\n      } else {\n        inst.remain = remain\n        inst.tick.emit(inst.remain)\n      }\n\n      inst.cdr.detectChanges()\n    }\n  })\n}\nfunction destroyCounter() {\n  counterSub && counterSub.unsubscribe()\n}\n\n/**\n * 倒计时组件\n */\n@Component({\n  selector: 'ngx-countdown',\n  templateUrl: './countdown.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class CountdownComponent implements OnInit, OnDestroy {\n  /** 格式 */\n  @Input() format: string = 'HH:mm:ss'\n  /** 是否自动开始 */\n  @Input() autoStart: boolean = true\n  /** 是否开启毫秒级渲染 */\n  @Input() millisecond: boolean = false\n  /** 自定义模版 */\n  @Input() render: TemplateRef<any>\n  /** 总毫秒数 */\n  @Input()\n  set time(value: number) {\n    this._time = Math.max(value, 0)\n    this.reset()\n  }\n  get time() {\n    return this._time\n  }\n\n  /** 倒计时完毕时触发 */\n  @Output() finish = new EventEmitter<any>()\n  /** 每倒计时一次都触发 */\n  @Output() tick = new EventEmitter<number>()\n\n  state: CountdownState = CountdownState.paused\n  get data(): CountdownData {\n    const noMillisecond = this.format.indexOf('S') === -1,\n      isPlaying = this.state === CountdownState.playing\n\n    // 即使 format 中没有设置毫秒，程序计算时候也会将毫秒计算进去，导致运行时秒数看上去总是小 1\n    // 此处在渲染时候手动 +1 秒，以追求视觉统一\n    const timeData = parseTimeData(this.remain + (noMillisecond && isPlaying ? 1000 : 0))\n    const formattedTime = parseFormat(this.format, timeData)\n    return {\n      formattedTime,\n      remain: this.remain,\n      fragments: formattedTime.split(':')\n    }\n  }\n\n  private _time: number = 60000\n  /** 剩余毫秒数 */\n  private remain: number\n  private endTime: number\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  ngOnInit() {\n    instances.push(this)\n    if (instances.length === 1) {\n      setupCounter()\n    }\n  }\n\n  ngOnDestroy() {\n    this.pause()\n    const index = instances.indexOf(this)\n    if (index !== -1) {\n      instances.splice(index, 1)\n    }\n    if (instances.length === 0) {\n      destroyCounter()\n    }\n  }\n\n  /**\n   * 继续倒计时\n   */\n  start() {\n    if (this.state === CountdownState.playing) {\n      return\n    }\n\n    if (this.state === CountdownState.finished) {\n      this.remain = this.time\n    }\n\n    this.endTime = Date.now() + this.remain\n    this.state = CountdownState.playing\n  }\n\n  /**\n   * 暂停倒计时\n   */\n  pause() {\n    this.state = CountdownState.paused\n  }\n\n  /**\n   * 重置倒计时\n   */\n  reset() {\n    this.pause()\n    this.remain = this.time\n    this.cdr.detectChanges()\n\n    if (this.autoStart) {\n      this.start()\n    }\n  }\n}\n"]}