ng-alertbar
Version:
A configurable alertbar for Angular
445 lines • 31.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, EventEmitter, Input, Output } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { Subject, timer } from 'rxjs';
import { filter, mapTo, switchMap, take, takeUntil } from 'rxjs/operators';
import { slide } from './animations';
import { defaults } from './defaults';
import { NgAlertbarService } from './ng-alertbar.service';
/** @type {?} */
var ALERT_LEAVE_ANIMATION_DURATION = 200;
var NgAlertbarComponent = /** @class */ (function () {
function NgAlertbarComponent(alertBarService, domSanitizer) {
this.alertBarService = alertBarService;
this.domSanitizer = domSanitizer;
this.queue = [];
this.queuePop = new Subject();
this.queueing = defaults.queueingEnabled;
this.lifeTime = defaults.lifeTimeMs;
this.showDelay = defaults.showDelayMs;
this.backgroundColor = defaults.backgroundColor;
this.borderColor = defaults.borderColor;
this.textColor = defaults.textColor;
this.widthMode = defaults.widthMode;
this.closeButton = defaults.closeButtonEnabled;
this.html = defaults.useHtml;
this.open = new EventEmitter();
this.close = new EventEmitter();
this.show = false;
this.destroy = new Subject();
}
Object.defineProperty(NgAlertbarComponent.prototype, "isFullWidth", {
get: /**
* @return {?}
*/
function () {
if (this.tempWidthMode) {
return this.tempWidthMode === 'full';
}
return this.widthMode === 'full';
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "showCloseButton", {
get: /**
* @return {?}
*/
function () {
if (this.tempCloseButton != null) {
return this.tempCloseButton;
}
return this.closeButton;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "useHtml", {
get: /**
* @return {?}
*/
function () {
if (this.tempHtml != null) {
return this.tempHtml;
}
return this.html;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "htmlMessage", {
get: /**
* @return {?}
*/
function () {
return this.domSanitizer.bypassSecurityTrustHtml(this.message);
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "openTriggerPostDelay$", {
/**
* The trigger stream after waiting the specified showDelay since the alert was triggered
*/
get: /**
* The trigger stream after waiting the specified showDelay since the alert was triggered
* @return {?}
*/
function () {
var _this = this;
return this.alertBarService.trigger$.pipe(switchMap((/**
* @param {?} trigger
* @return {?}
*/
function (trigger) {
/** @type {?} */
var options = trigger.options;
/** @type {?} */
var showDelay = (options && options.showDelay) || _this.showDelay;
return timer(showDelay).pipe(mapTo(trigger));
})), takeUntil(this.destroy));
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "postAlertLifetime$", {
/**
* The trigger stream after waiting the specified lifetime since the alert opened
*/
get: /**
* The trigger stream after waiting the specified lifetime since the alert opened
* @return {?}
*/
function () {
var _this = this;
return this.open.pipe(filter((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var options = _a.options;
return _this.shouldAlertAutoClose(options);
})), switchMap((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var options = _a.options;
/** @type {?} */
var lifeTime = (options && options.lifeTime) || _this.lifeTime;
return timer(lifeTime);
})), takeUntil(this.destroy));
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "cancelTrigger$", {
/**
* The service cancel trigger
*/
get: /**
* The service cancel trigger
* @return {?}
*/
function () {
return this.alertBarService.cancel$.pipe(takeUntil(this.destroy));
},
enumerable: true,
configurable: true
});
Object.defineProperty(NgAlertbarComponent.prototype, "alertLeaveTimer", {
/**
* Timer representing the delay taken for an alert to animate when exiting
*/
get: /**
* Timer representing the delay taken for an alert to animate when exiting
* @return {?}
*/
function () {
return timer(ALERT_LEAVE_ANIMATION_DURATION).pipe(take(1));
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
NgAlertbarComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
var _this = this;
this.openTriggerPostDelay$.subscribe((/**
* @param {?} trigger
* @return {?}
*/
function (trigger) { return _this.onTrigger(trigger); }));
this.queuePop.subscribe((/**
* @param {?} trigger
* @return {?}
*/
function (trigger) { return _this.showAlert(trigger); }));
this.postAlertLifetime$.subscribe((/**
* @return {?}
*/
function () { return _this.onClose(); }));
this.cancelTrigger$.subscribe((/**
* @return {?}
*/
function () { return _this.onClose(); }));
};
/**
* @return {?}
*/
NgAlertbarComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.destroy.next();
};
/**
* @private
* @param {?} trigger
* @return {?}
*/
NgAlertbarComponent.prototype.onTrigger = /**
* @private
* @param {?} trigger
* @return {?}
*/
function (trigger) {
if (this.queueing && !(trigger.options && trigger.options.bypassQueue) && this.show) {
this.queue.push(trigger);
return;
}
this.showAlert(trigger);
};
/**
* Sets up temp variables and shows the alert
* @param trigger The trigger to display
*/
/**
* Sets up temp variables and shows the alert
* @private
* @param {?} trigger The trigger to display
* @return {?}
*/
NgAlertbarComponent.prototype.showAlert = /**
* Sets up temp variables and shows the alert
* @private
* @param {?} trigger The trigger to display
* @return {?}
*/
function (trigger) {
this.clearTempOptions(); // Clear previous temporary options
this.assignTempOptions(trigger.options);
this.message = trigger.message;
this.show = true;
this.open.emit(trigger);
};
/**
* Closes any open alert. If there are any alerts waiting in the queue,
* the alert is popped off the queue and emitted for opening
*/
/**
* Closes any open alert. If there are any alerts waiting in the queue,
* the alert is popped off the queue and emitted for opening
* @return {?}
*/
NgAlertbarComponent.prototype.onClose = /**
* Closes any open alert. If there are any alerts waiting in the queue,
* the alert is popped off the queue and emitted for opening
* @return {?}
*/
function () {
var _this = this;
this.closeAlert();
if (this.queue.length > 0) {
this.alertLeaveTimer.subscribe((/**
* @return {?}
*/
function () {
_this.queuePop.next(_this.queue.shift());
}));
}
};
/**
* @private
* @return {?}
*/
NgAlertbarComponent.prototype.closeAlert = /**
* @private
* @return {?}
*/
function () {
this.show = false;
this.close.emit();
};
/**
* Clears out any temporary config options so that they
* do not persist beyond their single use
*/
/**
* Clears out any temporary config options so that they
* do not persist beyond their single use
* @private
* @return {?}
*/
NgAlertbarComponent.prototype.clearTempOptions = /**
* Clears out any temporary config options so that they
* do not persist beyond their single use
* @private
* @return {?}
*/
function () {
this.tempBackgroundColor = null;
this.tempBorderColor = null;
this.tempTextColor = null;
this.tempWidthMode = null;
this.tempCloseButton = null;
this.tempHtml = null;
};
/**
* Assigns the options included in the trigger to the temporary
* config variables so they can apply for the upcoming alert
* @param options The options passed in the trigger
*/
/**
* Assigns the options included in the trigger to the temporary
* config variables so they can apply for the upcoming alert
* @private
* @param {?} options The options passed in the trigger
* @return {?}
*/
NgAlertbarComponent.prototype.assignTempOptions = /**
* Assigns the options included in the trigger to the temporary
* config variables so they can apply for the upcoming alert
* @private
* @param {?} options The options passed in the trigger
* @return {?}
*/
function (options) {
if (!options) {
return;
}
this.tempBackgroundColor = options.backgroundColor;
this.tempBorderColor = options.borderColor;
this.tempTextColor = options.textColor;
this.tempWidthMode = options.widthMode;
this.tempCloseButton = options.closeButton;
this.tempHtml = options.html;
};
/**
* @private
* @param {?} options
* @return {?}
*/
NgAlertbarComponent.prototype.shouldAlertAutoClose = /**
* @private
* @param {?} options
* @return {?}
*/
function (options) {
if (options && options.lifeTime != null) {
return options.lifeTime > 0;
}
return this.lifeTime > 0; // Fallback to component setting
};
NgAlertbarComponent.decorators = [
{ type: Component, args: [{
selector: 'ng-alertbar',
template: "\n <div *ngIf=\"show\" [@slide] class=\"ng-alert-bar-wrapper\">\n <div\n class=\"ng-alert-bar\"\n [class.full-width]=\"isFullWidth\"\n [style.background]=\"tempBackgroundColor || backgroundColor\"\n [style.border-color]=\"tempBorderColor || borderColor\"\n >\n <span class=\"ng-alert-bar-text\" [style.color]=\"tempTextColor || textColor\">\n <span *ngIf=\"!useHtml; else htmlMessageContainer\">{{ message }}</span>\n <ng-template #htmlMessageContainer><span [innerHTML]=\"htmlMessage\"></span></ng-template>\n <span *ngIf=\"showCloseButton\" class=\"ng-alert-close\" (click)=\"onClose()\">×</span>\n </span>\n </div>\n </div>\n ",
animations: [slide],
styles: [".ng-alert-bar-wrapper{position:absolute;top:0;left:0;width:100%;text-align:center;pointer-events:none}.ng-alert-bar{pointer-events:all}.ng-alert-bar:not(.full-width){display:inline-block}.ng-alert-close{font-size:1.1em;margin-left:.25rem;vertical-align:middle;cursor:pointer}"]
}] }
];
/** @nocollapse */
NgAlertbarComponent.ctorParameters = function () { return [
{ type: NgAlertbarService },
{ type: DomSanitizer }
]; };
NgAlertbarComponent.propDecorators = {
queueing: [{ type: Input }],
lifeTime: [{ type: Input }],
showDelay: [{ type: Input }],
backgroundColor: [{ type: Input }],
borderColor: [{ type: Input }],
textColor: [{ type: Input }],
widthMode: [{ type: Input }],
closeButton: [{ type: Input }],
html: [{ type: Input }],
open: [{ type: Output }],
close: [{ type: Output }]
};
return NgAlertbarComponent;
}());
export { NgAlertbarComponent };
if (false) {
/**
* @type {?}
* @private
*/
NgAlertbarComponent.prototype.queue;
/**
* @type {?}
* @private
*/
NgAlertbarComponent.prototype.queuePop;
/** @type {?} */
NgAlertbarComponent.prototype.queueing;
/** @type {?} */
NgAlertbarComponent.prototype.lifeTime;
/** @type {?} */
NgAlertbarComponent.prototype.showDelay;
/** @type {?} */
NgAlertbarComponent.prototype.backgroundColor;
/** @type {?} */
NgAlertbarComponent.prototype.tempBackgroundColor;
/** @type {?} */
NgAlertbarComponent.prototype.borderColor;
/** @type {?} */
NgAlertbarComponent.prototype.tempBorderColor;
/** @type {?} */
NgAlertbarComponent.prototype.textColor;
/** @type {?} */
NgAlertbarComponent.prototype.tempTextColor;
/** @type {?} */
NgAlertbarComponent.prototype.widthMode;
/** @type {?} */
NgAlertbarComponent.prototype.tempWidthMode;
/** @type {?} */
NgAlertbarComponent.prototype.closeButton;
/** @type {?} */
NgAlertbarComponent.prototype.tempCloseButton;
/** @type {?} */
NgAlertbarComponent.prototype.html;
/** @type {?} */
NgAlertbarComponent.prototype.tempHtml;
/** @type {?} */
NgAlertbarComponent.prototype.open;
/** @type {?} */
NgAlertbarComponent.prototype.close;
/** @type {?} */
NgAlertbarComponent.prototype.show;
/** @type {?} */
NgAlertbarComponent.prototype.message;
/**
* @type {?}
* @private
*/
NgAlertbarComponent.prototype.destroy;
/**
* @type {?}
* @private
*/
NgAlertbarComponent.prototype.alertBarService;
/**
* @type {?}
* @private
*/
NgAlertbarComponent.prototype.domSanitizer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-alertbar.component.js","sourceRoot":"ng://ng-alertbar/","sources":["lib/ng-alertbar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { Subject, timer } from 'rxjs';\nimport { filter, mapTo, switchMap, take, takeUntil } from 'rxjs/operators';\nimport { slide } from './animations';\nimport { defaults } from './defaults';\nimport { AlertOptions, AlertTrigger } from './interface';\nimport { NgAlertbarService } from './ng-alertbar.service';\n\nconst ALERT_LEAVE_ANIMATION_DURATION = 200;\n\n@Component({\n  selector: 'ng-alertbar',\n  template: `\n    <div *ngIf=\"show\" [@slide] class=\"ng-alert-bar-wrapper\">\n      <div\n        class=\"ng-alert-bar\"\n        [class.full-width]=\"isFullWidth\"\n        [style.background]=\"tempBackgroundColor || backgroundColor\"\n        [style.border-color]=\"tempBorderColor || borderColor\"\n      >\n        <span class=\"ng-alert-bar-text\" [style.color]=\"tempTextColor || textColor\">\n          <span *ngIf=\"!useHtml; else htmlMessageContainer\">{{ message }}</span>\n          <ng-template #htmlMessageContainer><span [innerHTML]=\"htmlMessage\"></span></ng-template>\n          <span *ngIf=\"showCloseButton\" class=\"ng-alert-close\" (click)=\"onClose()\">&times;</span>\n        </span>\n      </div>\n    </div>\n  `,\n  styleUrls: ['./ng-alertbar.component.css'],\n  animations: [slide]\n})\nexport class NgAlertbarComponent implements OnInit, OnDestroy {\n  private queue: AlertTrigger[] = [];\n  private queuePop = new Subject<AlertTrigger>();\n\n  @Input() queueing = defaults.queueingEnabled;\n  @Input() lifeTime = defaults.lifeTimeMs;\n  @Input() showDelay = defaults.showDelayMs;\n\n  @Input() backgroundColor = defaults.backgroundColor;\n  tempBackgroundColor: string;\n  @Input() borderColor = defaults.borderColor;\n  tempBorderColor: string;\n  @Input() textColor = defaults.textColor;\n  tempTextColor: string;\n\n  @Input() widthMode = defaults.widthMode;\n  tempWidthMode: 'full' | 'partial';\n  @Input() closeButton = defaults.closeButtonEnabled;\n  tempCloseButton: boolean;\n  @Input() html = defaults.useHtml;\n  tempHtml: boolean;\n\n  @Output() open = new EventEmitter<AlertTrigger>();\n  @Output() close = new EventEmitter<void>();\n\n  show = false;\n  message: string;\n  private destroy = new Subject<void>();\n\n  get isFullWidth() {\n    if (this.tempWidthMode) {\n      return this.tempWidthMode === 'full';\n    }\n    return this.widthMode === 'full';\n  }\n\n  get showCloseButton() {\n    if (this.tempCloseButton != null) {\n      return this.tempCloseButton;\n    }\n    return this.closeButton;\n  }\n\n  get useHtml() {\n    if (this.tempHtml != null) {\n      return this.tempHtml;\n    }\n    return this.html;\n  }\n\n  get htmlMessage() {\n    return this.domSanitizer.bypassSecurityTrustHtml(this.message);\n  }\n\n  /**\n   * The trigger stream after waiting the specified showDelay since the alert was triggered\n   */\n  get openTriggerPostDelay$() {\n    return this.alertBarService.trigger$.pipe(\n      switchMap(trigger => {\n        const options = trigger.options;\n        const showDelay = (options && options.showDelay) || this.showDelay;\n        return timer(showDelay).pipe(mapTo(trigger));\n      }),\n      takeUntil(this.destroy)\n    );\n  }\n\n  /**\n   * The trigger stream after waiting the specified lifetime since the alert opened\n   */\n  get postAlertLifetime$() {\n    return this.open.pipe(\n      filter(({ options }) => this.shouldAlertAutoClose(options)),\n      switchMap(({ options }) => {\n        const lifeTime = (options && options.lifeTime) || this.lifeTime;\n        return timer(lifeTime);\n      }),\n      takeUntil(this.destroy)\n    );\n  }\n\n  /**\n   * The service cancel trigger\n   */\n  get cancelTrigger$() {\n    return this.alertBarService.cancel$.pipe(takeUntil(this.destroy));\n  }\n\n  /**\n   * Timer representing the delay taken for an alert to animate when exiting\n   */\n  get alertLeaveTimer() {\n    return timer(ALERT_LEAVE_ANIMATION_DURATION).pipe(take(1));\n  }\n\n  constructor(private alertBarService: NgAlertbarService, private domSanitizer: DomSanitizer) {}\n\n  ngOnInit() {\n    this.openTriggerPostDelay$.subscribe(trigger => this.onTrigger(trigger));\n    this.queuePop.subscribe(trigger => this.showAlert(trigger));\n    this.postAlertLifetime$.subscribe(() => this.onClose());\n    this.cancelTrigger$.subscribe(() => this.onClose());\n  }\n\n  ngOnDestroy() {\n    this.destroy.next();\n  }\n\n  private onTrigger(trigger: AlertTrigger) {\n    if (this.queueing && !(trigger.options && trigger.options.bypassQueue) && this.show) {\n      this.queue.push(trigger);\n      return;\n    }\n    this.showAlert(trigger);\n  }\n\n  /**\n   * Sets up temp variables and shows the alert\n   * @param trigger The trigger to display\n   */\n  private showAlert(trigger: AlertTrigger) {\n    this.clearTempOptions(); // Clear previous temporary options\n    this.assignTempOptions(trigger.options);\n    this.message = trigger.message;\n    this.show = true;\n    this.open.emit(trigger);\n  }\n\n  /**\n   * Closes any open alert. If there are any alerts waiting in the queue,\n   * the alert is popped off the queue and emitted for opening\n   */\n  onClose() {\n    this.closeAlert();\n    if (this.queue.length > 0) {\n      this.alertLeaveTimer.subscribe(() => {\n        this.queuePop.next(this.queue.shift());\n      });\n    }\n  }\n\n  private closeAlert() {\n    this.show = false;\n    this.close.emit();\n  }\n\n  /**\n   * Clears out any temporary config options so that they\n   * do not persist beyond their single use\n   */\n  private clearTempOptions(): void {\n    this.tempBackgroundColor = null;\n    this.tempBorderColor = null;\n    this.tempTextColor = null;\n    this.tempWidthMode = null;\n    this.tempCloseButton = null;\n    this.tempHtml = null;\n  }\n\n  /**\n   * Assigns the options included in the trigger to the temporary\n   * config variables so they can apply for the upcoming alert\n   * @param options The options passed in the trigger\n   */\n  private assignTempOptions(options: AlertOptions) {\n    if (!options) {\n      return;\n    }\n    this.tempBackgroundColor = options.backgroundColor;\n    this.tempBorderColor = options.borderColor;\n    this.tempTextColor = options.textColor;\n    this.tempWidthMode = options.widthMode;\n    this.tempCloseButton = options.closeButton;\n    this.tempHtml = options.html;\n  }\n\n  private shouldAlertAutoClose(options: AlertOptions) {\n    if (options && options.lifeTime != null) {\n      return options.lifeTime > 0;\n    }\n    return this.lifeTime > 0; // Fallback to component setting\n  }\n}\n"]}