@ngx-performance-ui/core
Version:
Ngx Performance UI - Core
1,798 lines (1,760 loc) • 48.7 kB
JavaScript
import compare from 'just-compare';
import { createTextMaskInputElement } from 'text-mask-core/dist/textMaskCore';
import { forkJoin, pipe, Subject, ReplaySubject, fromEvent } from 'rxjs';
import { filter, take, takeUntil, debounceTime, share } from 'rxjs/operators';
import { __decorate, __metadata, __spread, __assign } from 'tslib';
import { NgForOfContext, DOCUMENT, CommonModule } from '@angular/common';
import { HttpClientModule } from '@angular/common/http';
import { ChangeDetectorRef, Component, Injector, Input, Directive, ElementRef, HostListener, HostBinding, IterableDiffers, TemplateRef, ViewContainerRef, Renderer2, Injectable, Inject, defineInjectable, inject, APP_INITIALIZER, NgModule } from '@angular/core';
import { FormsModule, ReactiveFormsModule } from '@angular/forms';
import { RouterModule } from '@angular/router';
import { Store, Action, Selector, State, createSelector, NgxsModule } from '@ngxs/store';
import { TextMaskModule } from 'angular2-text-mask';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @template T, U
*/
var AbstractNgModelComponent = /** @class */ (function () {
function AbstractNgModelComponent(injector) {
this.injector = injector;
this.valueFn = (/**
* @param {?} value
* @return {?}
*/
function (value) { return (/** @type {?} */ (((/** @type {?} */ (value))))); });
this.valueLimitFn = (/**
* @param {?} value
* @return {?}
*/
function (value) { return false; });
this.cdRef = injector.get(ChangeDetectorRef);
}
Object.defineProperty(AbstractNgModelComponent.prototype, "value", {
get: /**
* @return {?}
*/
function () {
return this._value || this.defaultValue;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
value = this.valueFn((/** @type {?} */ (((/** @type {?} */ (value))))), this._value);
if (this.valueLimitFn(value, this._value) !== false)
return;
this._value = value;
this.notifyValueChange();
},
enumerable: true,
configurable: true
});
Object.defineProperty(AbstractNgModelComponent.prototype, "defaultValue", {
get: /**
* @return {?}
*/
function () {
return this._value;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
AbstractNgModelComponent.prototype.notifyValueChange = /**
* @return {?}
*/
function () {
if (this.onChange) {
this.onChange(this.value);
}
};
/**
* @param {?} value
* @return {?}
*/
AbstractNgModelComponent.prototype.writeValue = /**
* @param {?} value
* @return {?}
*/
function (value) {
var _this = this;
this._value = this.valueLimitFn(value, this._value) || value;
setTimeout((/**
* @return {?}
*/
function () { return _this.cdRef.detectChanges(); }), 0);
};
/**
* @param {?} fn
* @return {?}
*/
AbstractNgModelComponent.prototype.registerOnChange = /**
* @param {?} fn
* @return {?}
*/
function (fn) {
this.onChange = fn;
};
/**
* @param {?} fn
* @return {?}
*/
AbstractNgModelComponent.prototype.registerOnTouched = /**
* @param {?} fn
* @return {?}
*/
function (fn) {
this.onTouched = fn;
};
/**
* @param {?} isDisabled
* @return {?}
*/
AbstractNgModelComponent.prototype.setDisabledState = /**
* @param {?} isDisabled
* @return {?}
*/
function (isDisabled) {
this.disabled = isDisabled;
};
AbstractNgModelComponent.decorators = [
{ type: Component, args: [{ template: '' }] }
];
/** @nocollapse */
AbstractNgModelComponent.ctorParameters = function () { return [
{ type: Injector }
]; };
AbstractNgModelComponent.propDecorators = {
disabled: [{ type: Input }],
id: [{ type: Input }],
ngModel: [{ type: Input }],
valueFn: [{ type: Input }],
valueLimitFn: [{ type: Input }],
value: [{ type: Input }]
};
return AbstractNgModelComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var EventListenerPublish = /** @class */ (function () {
function EventListenerPublish(payload) {
this.payload = payload;
}
EventListenerPublish.type = '[EventListener] Publish';
return EventListenerPublish;
}());
var EventListenerAdd = /** @class */ (function () {
function EventListenerAdd(payload) {
this.payload = payload;
}
EventListenerAdd.type = '[EventListener] Add';
return EventListenerAdd;
}());
var EventListenerScrollVertical = /** @class */ (function () {
function EventListenerScrollVertical(payload) {
this.payload = payload;
}
EventListenerScrollVertical.type = '[EventListener] Scroll Vertical';
return EventListenerScrollVertical;
}());
var EventListenerRemove = /** @class */ (function () {
function EventListenerRemove(payload) {
this.payload = payload;
}
EventListenerRemove.type = '[EventListener] Remove';
return EventListenerRemove;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LoaderSetProgress = /** @class */ (function () {
function LoaderSetProgress(payload) {
this.payload = payload;
}
LoaderSetProgress.type = '[Loader] Set Progress';
return LoaderSetProgress;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var RouterOutletComponent = /** @class */ (function () {
function RouterOutletComponent() {
}
RouterOutletComponent.decorators = [
{ type: Component, args: [{
selector: 'p-router-outlet',
template: "\n <router-outlet></router-outlet>\n "
}] }
];
return RouterOutletComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var LOADER_DEFAULTS = {
progress: false,
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AutofocusDirective = /** @class */ (function () {
function AutofocusDirective(elRef) {
this.elRef = elRef;
this.enable = false;
this.delay = 0;
}
/**
* @return {?}
*/
AutofocusDirective.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
var _this = this;
if (this.enable)
setTimeout((/**
* @return {?}
*/
function () { return _this.elRef.nativeElement.focus(); }), this.delay);
};
AutofocusDirective.decorators = [
{ type: Directive, args: [{
selector: '[autofocus]',
},] }
];
/** @nocollapse */
AutofocusDirective.ctorParameters = function () { return [
{ type: ElementRef }
]; };
AutofocusDirective.propDecorators = {
enable: [{ type: Input, args: ['autofocus',] }],
delay: [{ type: Input, args: ['autofocusDelay',] }]
};
return AutofocusDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AutosizeDirective = /** @class */ (function () {
function AutosizeDirective(element) {
this.element = element;
this.enabled = true;
}
/**
* @return {?}
*/
AutosizeDirective.prototype.onInput = /**
* @return {?}
*/
function () {
if (!this.enabled)
return;
this.element.nativeElement.style.overflow = 'hidden';
this.element.nativeElement.style.height = 'auto';
this.element.nativeElement.style.height = this.element.nativeElement.scrollHeight + 'px';
};
/**
* @return {?}
*/
AutosizeDirective.prototype.ngAfterContentInit = /**
* @return {?}
*/
function () {
this.onInput();
};
AutosizeDirective.decorators = [
{ type: Directive, args: [{
selector: '[autosize]',
},] }
];
/** @nocollapse */
AutosizeDirective.ctorParameters = function () { return [
{ type: ElementRef }
]; };
AutosizeDirective.propDecorators = {
enabled: [{ type: Input, args: ['autosize',] }],
onInput: [{ type: HostListener, args: ['input',] }]
};
return AutosizeDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var EllipsisDirective = /** @class */ (function () {
function EllipsisDirective(elRef) {
this.elRef = elRef;
this.pEllipsisEnabled = true;
}
Object.defineProperty(EllipsisDirective.prototype, "maxWidth", {
get: /**
* @return {?}
*/
function () {
return this.pEllipsis || '100%';
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
EllipsisDirective.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
var _this = this;
setTimeout((/**
* @return {?}
*/
function () {
_this.title = _this.title || ((/** @type {?} */ (_this.elRef.nativeElement))).innerText;
}), 0);
};
EllipsisDirective.decorators = [
{ type: Directive, args: [{
selector: '[pEllipsis]',
},] }
];
/** @nocollapse */
EllipsisDirective.ctorParameters = function () { return [
{ type: ElementRef }
]; };
EllipsisDirective.propDecorators = {
pEllipsis: [{ type: Input }],
maxWidth: [{ type: HostBinding, args: ['style.max-width',] }],
title: [{ type: HostBinding, args: ['title',] }, { type: Input }],
pEllipsisEnabled: [{ type: HostBinding, args: ['class.p-ellipsis',] }, { type: Input }]
};
return EllipsisDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @template T
*/
var /**
* @template T
*/
RecordViewTuple = /** @class */ (function () {
function RecordViewTuple(record, view) {
this.record = record;
this.view = view;
}
return RecordViewTuple;
}());
var ForDirective = /** @class */ (function () {
function ForDirective(iterable, tempRef, vcRef) {
this.iterable = iterable;
this.tempRef = tempRef;
this.vcRef = vcRef;
}
Object.defineProperty(ForDirective.prototype, "compareFn", {
get: /**
* @return {?}
*/
function () {
return this.compareBy || compare;
},
enumerable: true,
configurable: true
});
Object.defineProperty(ForDirective.prototype, "containCompareFn", {
get: /**
* @return {?}
*/
function () {
return (this.containCompareBy ||
((/**
* @param {?} value
* @param {?} comparision
* @return {?}
*/
function (value, comparision) { return value.toLocaleLowerCase().indexOf(comparision.toLocaleLowerCase()) > -1; })));
},
enumerable: true,
configurable: true
});
Object.defineProperty(ForDirective.prototype, "trackByFn", {
get: /**
* @return {?}
*/
function () {
return this.trackBy || ((/**
* @param {?} index
* @param {?=} item
* @return {?}
*/
function (index, item) {
if (item === void 0) { item = {}; }
return item.id || index;
}));
},
enumerable: true,
configurable: true
});
/**
* @private
* @param {?} changes
* @param {?} items
* @return {?}
*/
ForDirective.prototype.applyChanges = /**
* @private
* @param {?} changes
* @param {?} items
* @return {?}
*/
function (changes, items) {
var _this = this;
/** @type {?} */
var insertTuples = [];
changes.forEachOperation((/**
* @param {?} item
* @param {?} adjustedPreviousIndex
* @param {?} currentIndex
* @return {?}
*/
function (item, adjustedPreviousIndex, currentIndex) {
if (item.previousIndex == null) {
/** @type {?} */
var view = _this.vcRef.createEmbeddedView(_this.tempRef, new NgForOfContext((/** @type {?} */ (null)), items, -1, -1), currentIndex);
/** @type {?} */
var tuple = new RecordViewTuple(item, view);
insertTuples.push(tuple);
}
else if (currentIndex == null) {
_this.vcRef.remove(adjustedPreviousIndex);
}
else {
/** @type {?} */
var view = (/** @type {?} */ (_this.vcRef.get(adjustedPreviousIndex)));
_this.vcRef.move(view, currentIndex);
/** @type {?} */
var tuple = new RecordViewTuple(item, (/** @type {?} */ (view)));
insertTuples.push(tuple);
}
}));
for (var i = 0; i < insertTuples.length; i++) {
insertTuples[i].view.context.$implicit = insertTuples[i].record.item;
}
for (var i = 0, ilen = this.vcRef.length; i < ilen; i++) {
/** @type {?} */
var viewRef = (/** @type {?} */ (this.vcRef.get(i)));
viewRef.context.index = i;
viewRef.context.count = ilen;
viewRef.context.ngForOf = items;
}
changes.forEachIdentityChange((/**
* @param {?} record
* @return {?}
*/
function (record) {
/** @type {?} */
var viewRef = (/** @type {?} */ (_this.vcRef.get(record.currentIndex)));
viewRef.context.$implicit = record.item;
}));
};
/**
* @return {?}
*/
ForDirective.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
var _this = this;
if (!Array.isArray(this.items))
throw 'pForOf must be an array!';
/** @type {?} */
var items = [];
if (this.filterValue !== undefined) {
/** @type {?} */
var compareFn_1;
if (this.filterContain) {
if (typeof this.filterValue !== 'string') {
throw 'filterValue must be a string when filterContain is true';
}
compareFn_1 = this.containCompareFn;
}
else {
compareFn_1 = this.compareFn;
}
items = this.items.filter((/**
* @param {?} item
* @return {?}
*/
function (item) { return compareFn_1(_this.filterKey ? item[_this.filterKey] : item, _this.filterValue); }));
}
else {
items = this.items;
}
if (!this.iterableDiffer && items) {
this.iterableDiffer = this.iterable.find(items).create(this.trackByFn);
}
if (this.iterableDiffer) {
/** @type {?} */
var changes = this.iterableDiffer.diff(items);
if (changes)
this.applyChanges(changes, items);
}
};
ForDirective.decorators = [
{ type: Directive, args: [{
selector: '[pFor]',
},] }
];
/** @nocollapse */
ForDirective.ctorParameters = function () { return [
{ type: IterableDiffers },
{ type: TemplateRef },
{ type: ViewContainerRef }
]; };
ForDirective.propDecorators = {
items: [{ type: Input, args: ['pForOf',] }],
trackBy: [{ type: Input, args: ['pForTrackBy',] }],
filterKey: [{ type: Input, args: ['pForFilterKey',] }],
filterValue: [{ type: Input, args: ['pForFilterValue',] }],
filterContain: [{ type: Input, args: ['pForFilterContain',] }],
compareBy: [{ type: Input, args: ['pForCompareBy',] }],
containCompareBy: [{ type: Input, args: ['pForContainCompareBy',] }]
};
return ForDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} states
* @return {?}
*/
function ngxsLogExcept(states) {
if (!states.length)
return console;
/** @type {?} */
var NO_LOG = new RegExp('\\[(' + states.join('|') + ')\\]');
return __assign({}, console, { silent: false, group: (/**
* @param {?} message
* @return {?}
*/
function (message) {
if (NO_LOG.test(message)) {
this.silent = true;
return;
}
this.silent = false;
console.group(message);
}), groupCollapsed: (/**
* @param {?} message
* @return {?}
*/
function (message) {
if (NO_LOG.test(message)) {
this.silent = true;
return;
}
this.silent = false;
console.groupCollapsed(message);
}), log: (/**
* @param {?} message
* @param {...?} args
* @return {?}
*/
function (message) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (this.silent)
return;
console.log.apply(console, __spread([message], args));
}) });
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} value
* @return {?}
*/
function notNull(value) {
return value !== null;
}
/**
* @param {?} value
* @return {?}
*/
function transformToArray(value) {
if (Array.isArray(value))
return value;
return [value];
}
/**
* @param {?} value
* @param {?} mask
* @return {?}
*/
function transformByRegex(value, mask) {
if (typeof value === 'number')
value = String(value);
/** @type {?} */
var inputElement = document.createElement('input');
inputElement.type = 'text';
/** @type {?} */
var textMaskInputElement = createTextMaskInputElement(__assign({}, mask, { inputElement: inputElement }));
textMaskInputElement.update(value);
return inputElement.value;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?=} a
* @return {?}
*/
function uuid(a) {
return a
? (a ^ ((Math.random() * 16) >> (a / 4))).toString(16)
: ('' + 1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {...?} streams
* @return {?}
*/
function fromFork() {
var streams = [];
for (var _i = 0; _i < arguments.length; _i++) {
streams[_i] = arguments[_i];
}
return forkJoin.apply(void 0, __spread(streams.map((/**
* @param {?} stream
* @return {?}
*/
function (stream) { return stream.pipe(take(1)); }))));
}
/**
* @template T
* @param {?} destroy$
* @return {?}
*/
function takeUntilNotNull(destroy$) {
return pipe(filter(notNull), takeUntil(destroy$));
}
/**
* @template T
* @param {?} component
* @return {?}
*/
function takeUntilDestroy(component) {
/** @type {?} */
var proto = Object.getPrototypeOf(component);
/** @type {?} */
var onDestroy = proto.ngOnDestroy;
if (!(onDestroy && typeof onDestroy === 'function')) {
throw new Error((proto.constructor.name || 'Component') +
' must have the "ngOnDestroy" method for takeUntilDestroy operator to work.' +
' You may use XcDestroy decorator on component class for quick implementation.');
}
/** @type {?} */
var destroy$ = new Subject();
proto.ngOnDestroy = (/**
* @return {?}
*/
function () {
onDestroy.apply(this, arguments);
destroy$.next();
destroy$.complete();
});
return takeUntil(destroy$);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var CHARMAP = {
á: 'a',
Á: 'A',
À: 'A',
à: 'a',
Ă: 'A',
ă: 'a',
Ắ: 'A',
ắ: 'a',
ằ: 'a',
Ằ: 'A',
Ẵ: 'A',
ẵ: 'a',
ẳ: 'a',
Ẳ: 'A',
â: 'a',
Â: 'A',
ấ: 'a',
Ấ: 'A',
ầ: 'a',
Ầ: 'A',
ǎ: 'a',
Ǎ: 'A',
å: 'a',
Å: 'A',
Ǻ: 'A',
ǻ: 'a',
ä: 'a',
Ä: 'A',
a̋: 'a',
A̋: 'A',
Ã: 'A',
ã: 'a',
A̧: 'A',
a̧: 'a',
Ą: 'A',
ą: 'a',
ā: 'a',
Ā: 'A',
ȁ: 'a',
Ȁ: 'A',
ȃ: 'a',
Ȃ: 'A',
Ặ: 'A',
ặ: 'a',
æ: 'a',
// ae
Æ: 'A',
// AE
Ǽ: 'A',
// AE
ǽ: 'a',
// ae
b̌: 'b',
B̌: 'B',
b̧: 'b',
B̧: 'B',
ć: 'c',
Ć: 'C',
c̆: 'c',
C̆: 'C',
ĉ: 'c',
Ĉ: 'C',
č: 'c',
Č: 'C',
ċ: 'c',
Ċ: 'C',
Ç: 'C',
ç: 'c',
Ḉ: 'C',
ḉ: 'c',
č̣: 'c',
Č̣: 'C',
Ď: 'D',
ď: 'd',
ḑ: 'd',
Ḑ: 'D',
đ: 'd',
Đ: 'D',
Ð: 'D',
ð: 'd',
É: 'E',
é: 'e',
È: 'E',
è: 'e',
Ĕ: 'E',
ĕ: 'e',
ê: 'e',
Ê: 'E',
Ế: 'E',
ế: 'e',
ề: 'e',
Ề: 'E',
Ê̌: 'E',
ê̌: 'e',
Ě: 'E',
ě: 'e',
ë: 'e',
Ë: 'E',
e̋: 'e',
E̋: 'E',
Ė: 'E',
ė: 'e',
Ȩ: 'E',
ȩ: 'e',
ḝ: 'e',
Ḝ: 'E',
Ę: 'E',
ę: 'e',
Ē: 'E',
ē: 'e',
Ḗ: 'E',
ḗ: 'e',
Ḕ: 'E',
ḕ: 'e',
Ȅ: 'E',
ȅ: 'e',
Ȇ: 'E',
ȇ: 'e',
ɛ̧: 'e',
Ɛ̧: 'E',
f̌: 'f',
F̌: 'F',
ƒ: 'f',
ǵ: 'g',
Ǵ: 'G',
ğ: 'g',
Ğ: 'G',
Ĝ: 'G',
ĝ: 'g',
ǧ: 'g',
Ǧ: 'G',
Ġ: 'G',
ġ: 'g',
ģ: 'g',
Ģ: 'G',
Ĥ: 'H',
ĥ: 'h',
ȟ: 'h',
Ȟ: 'H',
ḩ: 'h',
Ḩ: 'H',
ħ: 'h',
Ħ: 'H',
ḫ: 'h',
Ḫ: 'H',
í: 'i',
Í: 'I',
Ì: 'I',
ì: 'i',
Ĭ: 'I',
ĭ: 'i',
Î: 'I',
î: 'i',
ǐ: 'i',
Ǐ: 'I',
ï: 'i',
Ï: 'I',
ḯ: 'i',
Ḯ: 'I',
I̋: 'I',
i̋: 'i',
ĩ: 'i',
Ĩ: 'I',
İ: 'I',
I̧: 'I',
i̧: 'i',
Į: 'I',
į: 'i',
ī: 'i',
Ī: 'I',
ȉ: 'i',
Ȉ: 'I',
ȋ: 'i',
Ȋ: 'I',
ij: 'i',
// ij
IJ: 'I',
// IJ
ı: 'i',
Ɨ̧: 'I',
ɨ̧: 'i',
ĵ: 'j',
Ĵ: 'J',
ǰ: 'j',
J̌: 'J',
Ḱ: 'K',
ḱ: 'k',
k̆: 'k',
K̆: 'K',
ǩ: 'k',
Ǩ: 'K',
ķ: 'k',
Ķ: 'K',
Ĺ: 'L',
ĺ: 'l',
Ľ: 'L',
ľ: 'l',
ļ: 'l',
Ļ: 'L',
ł: 'l',
Ł: 'l',
Ŀ: 'L',
ŀ: 'l',
Ḿ: 'M',
ḿ: 'm',
m̆: 'm',
M̆: 'M',
m̌: 'm',
M̌: 'M',
M̧: 'M',
m̧: 'm',
Ń: 'N',
ń: 'n',
Ǹ: 'N',
ǹ: 'n',
n̆: 'n',
N̆: 'N',
Ň: 'N',
ň: 'n',
ñ: 'n',
Ñ: 'N',
Ņ: 'N',
ņ: 'n',
ó: 'o',
Ó: 'O',
Ò: 'O',
ò: 'o',
Ŏ: 'O',
ŏ: 'o',
Ô: 'O',
ô: 'o',
ố: 'o',
Ố: 'O',
ồ: 'o',
Ồ: 'O',
Ǒ: 'O',
ǒ: 'o',
Ö: 'O',
ö: 'o',
ő: 'o',
Ő: 'O',
Õ: 'O',
õ: 'o',
ṍ: 'o',
Ṍ: 'O',
Ø: 'O',
ø: 'o',
Ǿ: 'O',
ǿ: 'o',
o̧: 'o',
O̧: 'O',
Ō: 'O',
ō: 'o',
ṓ: 'o',
Ṓ: 'O',
ṑ: 'o',
Ṑ: 'O',
ȍ: 'o',
Ȍ: 'O',
ȏ: 'o',
Ȏ: 'O',
ơ: 'o',
Ơ: 'O',
œ: 'o',
// oe
Œ: 'O',
// OE
ṕ: 'p',
Ṕ: 'P',
p̆: 'p',
P̆: 'P',
P̌: 'P',
p̌: 'p',
Q̌: 'Q',
q̌: 'q',
Q̧: 'Q',
q̧: 'q',
ŕ: 'r',
Ŕ: 'R',
r̆: 'r',
R̆: 'R',
Ř: 'R',
ř: 'r',
ŗ: 'r',
Ŗ: 'R',
Ř̩: 'R',
ř̩: 'r',
ȑ: 'r',
Ȑ: 'R',
Ȓ: 'R',
ȓ: 'r',
Ś: 'S',
ś: 's',
Ṥ: 'S',
ṥ: 's',
Ŝ: 'S',
ŝ: 's',
š: 's',
Š: 'S',
Ṧ: 'S',
ṧ: 's',
ş: 's',
Ş: 'S',
ș: 's',
Ș: 'S',
ſ: 's',
T̆: 'T',
t̆: 't',
Ť: 'T',
ť: 't',
ţ: 't',
Ţ: 'T',
Ț: 'T',
ț: 't',
ŧ: 't',
Ŧ: 'T',
Ú: 'U',
ú: 'u',
ù: 'u',
Ù: 'U',
ŭ: 'u',
Ŭ: 'U',
Û: 'U',
û: 'u',
ǔ: 'u',
Ǔ: 'U',
Ů: 'U',
ů: 'u',
ü: 'u',
Ü: 'U',
ǘ: 'u',
Ǘ: 'U',
Ǜ: 'U',
ǜ: 'u',
ǚ: 'u',
Ǚ: 'U',
ǖ: 'u',
Ǖ: 'U',
Ű: 'U',
ű: 'u',
ũ: 'u',
Ũ: 'U',
Ṹ: 'U',
ṹ: 'u',
u̧: 'u',
U̧: 'U',
Ų: 'U',
ų: 'u',
Ū: 'U',
ū: 'u',
ȕ: 'u',
Ȕ: 'U',
Ȗ: 'U',
ȗ: 'u',
ư: 'u',
Ư: 'U',
ứ: 'u',
Ứ: 'U',
ừ: 'u',
Ừ: 'U',
V̆: 'V',
v̆: 'v',
v̌: 'v',
V̌: 'V',
Ẃ: 'W',
ẃ: 'w',
Ẁ: 'W',
ẁ: 'w',
ŵ: 'w',
Ŵ: 'W',
W̌: 'W',
w̌: 'w',
x́: 'x',
X́: 'X',
X̆: 'X',
x̆: 'x',
x̌: 'x',
X̌: 'X',
X̧: 'X',
x̧: 'x',
Ý: 'Y',
ý: 'y',
Ỳ: 'Y',
ỳ: 'y',
y̆: 'y',
Y̆: 'Y',
Ŷ: 'Y',
ŷ: 'y',
y̌: 'y',
Y̌: 'Y',
ÿ: 'y',
Ÿ: 'Y',
ź: 'z',
Ź: 'Z',
Ž: 'Z',
ž: 'z',
Ż: 'Z',
ż: 'z',
Z̧: 'Z',
z̧: 'z',
};
/** @type {?} */
var DIACRITICS = new RegExp(Object.keys(CHARMAP).join('|'), 'g');
/**
* @param {?} text
* @return {?}
*/
function normalizeDiacritics(text) {
if (!text || text === '')
return;
return text.replace(DIACRITICS, (/**
* @param {?} match
* @return {?}
*/
function (match) { return CHARMAP[match]; }));
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var HighlightDirective = /** @class */ (function () {
function HighlightDirective(elRef, renderer) {
this.elRef = elRef;
this.renderer = renderer;
this.value = '';
this.class = 'text-primary';
this.hide = false;
this.hideWhenNull = false;
this.hideClass = 'd-none';
}
Object.defineProperty(HighlightDirective.prototype, "pHighlight", {
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
if (!value && value !== '' && typeof value !== 'string')
return;
this.value = normalizeDiacritics(value.replace(/\s+/gm, ' '));
},
enumerable: true,
configurable: true
});
/**
* @private
* @param {?} text
* @return {?}
*/
HighlightDirective.prototype.setHighlight = /**
* @private
* @param {?} text
* @return {?}
*/
function (text) {
var _this = this;
if (!this.value || this.value === '' || this.value === ' ')
return text;
text = normalizeDiacritics(text.replace(/\s+/gm, ' '));
/** @type {?} */
var splitText = text.split(' ').filter((/**
* @param {?} value
* @return {?}
*/
function (value) { return value !== ''; }));
/** @type {?} */
var splitValue = this.value.split(' ').filter((/**
* @param {?} value
* @return {?}
*/
function (value) { return value !== ''; }));
/** @type {?} */
var found = [];
splitValue.forEach((/**
* @param {?} value
* @return {?}
*/
function (value) {
found = __spread(found, splitText
.map((/**
* @param {?} text
* @param {?} index
* @return {?}
*/
function (text, index) { return ({ text: text, index: index, value: value }); }))
.filter((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var text = _a.text;
return text.toLocaleLowerCase().indexOf(value.toLocaleLowerCase()) > -1;
})));
}));
if (!found.length)
return text;
return splitText.reduce((/**
* @param {?} acc
* @param {?} val
* @param {?} index
* @return {?}
*/
function (acc, val, index) {
var value = (found.find((/**
* @param {?} data
* @return {?}
*/
function (data) { return data.index === index; })) || ((/** @type {?} */ ({})))).value;
if (value) {
/** @type {?} */
var text_1 = val.substr(val.toLocaleLowerCase().indexOf(value.toLocaleLowerCase()), value.length);
val = val.replace(RegExp(value, 'mig'), "<span class=\"" + _this.class + "\">" + text_1 + "</span>");
}
return (acc += val + " ");
}), '');
};
/**
* @return {?}
*/
HighlightDirective.prototype.ngOnChanges = /**
* @return {?}
*/
function () {
var _this = this;
setTimeout((/**
* @return {?}
*/
function () {
/** @type {?} */
var element = (/** @type {?} */ (_this.elRef.nativeElement));
/** @type {?} */
var text = element.textContent;
if (!text)
return;
_this.renderer.removeClass(element, _this.hideClass);
/** @type {?} */
var patchedText = _this.setHighlight(text);
element.innerHTML = patchedText;
if (patchedText.indexOf('span') < 0 && _this.hide && (_this.hideWhenNull ? true : _this.value)) {
_this.renderer.addClass(element, _this.hideClass);
}
}), 0);
};
HighlightDirective.decorators = [
{ type: Directive, args: [{
selector: '[pHighlight]',
},] }
];
/** @nocollapse */
HighlightDirective.ctorParameters = function () { return [
{ type: ElementRef },
{ type: Renderer2 }
]; };
HighlightDirective.propDecorators = {
pHighlight: [{ type: Input }],
class: [{ type: Input, args: ['pHighlightClass',] }],
hide: [{ type: Input, args: ['pHighlightHide',] }],
hideWhenNull: [{ type: Input, args: ['pHighlightHideWhenNull',] }],
hideClass: [{ type: Input, args: ['pHighlightHideClass',] }]
};
return HighlightDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ScrollListenerDirective = /** @class */ (function () {
function ScrollListenerDirective(store) {
this.store = store;
this.dispatch$ = new Subject();
}
/**
* @param {?} event
* @return {?}
*/
ScrollListenerDirective.prototype.publish = /**
* @param {?} event
* @return {?}
*/
function (event) {
this.dispatch$.next(event);
};
/**
* @return {?}
*/
ScrollListenerDirective.prototype.ngOnInit = /**
* @return {?}
*/
function () {
var _this = this;
this.dispatch$
.pipe(debounceTime(300), takeUntilDestroy(this))
.subscribe((/**
* @param {?} event
* @return {?}
*/
function (event) { return _this.store.dispatch(new EventListenerScrollVertical(event)); }));
};
/**
* @return {?}
*/
ScrollListenerDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () { };
ScrollListenerDirective.decorators = [
{ type: Directive, args: [{ selector: 'perfect-scrollbar' },] }
];
/** @nocollapse */
ScrollListenerDirective.ctorParameters = function () { return [
{ type: Store }
]; };
ScrollListenerDirective.propDecorators = {
publish: [{ type: HostListener, args: ['psScrollY', ['$event'],] }]
};
return ScrollListenerDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var EventHandler = /** @class */ (function () {
function EventHandler(store) {
var _this = this;
this.store = store;
setTimeout((/**
* @return {?}
*/
function () {
_this.store.dispatch(new EventListenerAdd(['click', 'keyup', 'mousemove']));
}), 0);
}
EventHandler.decorators = [
{ type: Injectable, args: [{
providedIn: 'root',
},] }
];
/** @nocollapse */
EventHandler.ctorParameters = function () { return [
{ type: Store }
]; };
/** @nocollapse */ EventHandler.ngInjectableDef = defineInjectable({ factory: function EventHandler_Factory() { return new EventHandler(inject(Store)); }, token: EventHandler, providedIn: "root" });
return EventHandler;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var EventListener;
(function (EventListener) {
/**
* @record
*/
function State$$1() { }
EventListener.State = State$$1;
EventListener.debonceTimes = {
click: 300,
mousemove: 500,
resize: 700,
keyup: 300,
};
})(EventListener || (EventListener = {}));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var Loader;
(function (Loader) {
/**
* @record
*/
function State$$1() { }
Loader.State = State$$1;
})(Loader || (Loader = {}));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var Mask;
(function (Mask) {
/**
* @record
*/
function Config() { }
Mask.Config = Config;
})(Mask || (Mask = {}));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LazyLoadScriptService = /** @class */ (function () {
function LazyLoadScriptService(document) {
this.document = document;
this._loadedLibraries = {};
}
/**
* @param {?} url
* @return {?}
*/
LazyLoadScriptService.prototype.loadScript = /**
* @param {?} url
* @return {?}
*/
function (url) {
var _this = this;
if (this._loadedLibraries[url]) {
return this._loadedLibraries[url].asObservable();
}
this._loadedLibraries[url] = new ReplaySubject();
/** @type {?} */
var script = this.document.createElement('script');
script.type = 'text/javascript';
script.src = url;
script.onload = (/**
* @return {?}
*/
function () {
_this._loadedLibraries[url].next();
_this._loadedLibraries[url].complete();
});
this.document.body.appendChild(script);
return this._loadedLibraries[url].asObservable();
};
LazyLoadScriptService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root',
},] }
];
/** @nocollapse */
LazyLoadScriptService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
]; };
/** @nocollapse */ LazyLoadScriptService.ngInjectableDef = defineInjectable({ factory: function LazyLoadScriptService_Factory() { return new LazyLoadScriptService(inject(DOCUMENT)); }, token: LazyLoadScriptService, providedIn: "root" });
return LazyLoadScriptService;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var EventListenerState = /** @class */ (function () {
function EventListenerState() {
this.subscriptions = {};
}
EventListenerState_1 = EventListenerState;
/**
* @param {?} state
* @return {?}
*/
EventListenerState.getAll = /**
* @param {?} state
* @return {?}
*/
function (state) {
return state;
};
/**
* @param {?} key
* @return {?}
*/
EventListenerState.getOne = /**
* @param {?} key
* @return {?}
*/
function (key) {
/** @type {?} */
var selector = createSelector([EventListenerState_1], (/**
* @param {?} state
* @return {?}
*/
function (state) {
return state[key];
}));
return selector;
};
/**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
EventListenerState.prototype.addEventListener = /**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
function (_a, _b) {
var _this = this;
var dispatch = _a.dispatch;
var payload = _b.payload;
transformToArray(payload).forEach((/**
* @param {?} key
* @return {?}
*/
function (key) {
if (_this.subscriptions[key])
return;
_this.subscriptions[key] = fromEvent(key === 'resize' ? window : document, key)
.pipe(debounceTime(EventListener.debonceTimes[key] || 300), share())
.subscribe((/**
* @param {?} event
* @return {?}
*/
function (event) { return dispatch(new EventListenerPublish(event)); }));
}));
};
/**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
EventListenerState.prototype.publishEvent = /**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
function (_a, _b) {
var patchState = _a.patchState;
var payload = _b.payload;
var _c;
patchState((_c = {}, _c[payload.type] = payload, _c));
};
/**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
EventListenerState.prototype.removeEventListener = /**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
function (_a, _b) {
var _this = this;
var patchState = _a.patchState;
var payload = _b.payload;
transformToArray(payload).forEach((/**
* @param {?} key
* @return {?}
*/
function (key) {
var _a;
if (_this.subscriptions[key]) {
_this.subscriptions[key].unsubscribe();
delete _this.subscriptions[key];
patchState((_a = {},
_a[key] = null,
_a));
}
}));
};
var EventListenerState_1;
__decorate([
Action(EventListenerAdd),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object, EventListenerAdd]),
__metadata("design:returntype", void 0)
], EventListenerState.prototype, "addEventListener", null);
__decorate([
Action(EventListenerPublish),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object, EventListenerPublish]),
__metadata("design:returntype", void 0)
], EventListenerState.prototype, "publishEvent", null);
__decorate([
Action(EventListenerRemove),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object, EventListenerRemove]),
__metadata("design:returntype", void 0)
], EventListenerState.prototype, "removeEventListener", null);
__decorate([
Selector(),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", void 0)
], EventListenerState, "getAll", null);
EventListenerState = EventListenerState_1 = __decorate([
State({
name: 'EventListenerState',
defaults: {},
})
], EventListenerState);
return EventListenerState;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LoaderState = /** @class */ (function () {
function LoaderState() {
}
/**
* @param {?} __0
* @return {?}
*/
LoaderState.progress = /**
* @param {?} __0
* @return {?}
*/
function (_a) {
var progress = _a.progress;
return progress;
};
/**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
LoaderState.prototype.addEventListener = /**
* @param {?} __0
* @param {?} __1
* @return {?}
*/
function (_a, _b) {
var patchState = _a.patchState;
var payload = _b.payload;
patchState({ progress: payload });
};
__decorate([
Action(LoaderSetProgress),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object, LoaderSetProgress]),
__metadata("design:returntype", void 0)
], LoaderState.prototype, "addEventListener", null);
__decorate([
Selector(),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", void 0)
], LoaderState, "progress", null);
LoaderState = __decorate([
State({
name: 'LoaderState',
defaults: LOADER_DEFAULTS,
})
], LoaderState);
return LoaderState;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var CoreModule = /** @class */ (function () {
function CoreModule() {
}
/**
* @return {?}
*/
CoreModule.forRoot = /**
* @return {?}
*/
function () {
return {
ngModule: CoreModule,
providers: [
{
provide: APP_INITIALIZER,
deps: [EventHandler],
useFactory: noop,
multi: true,
},
],
};
};
CoreModule.decorators = [
{ type: NgModule, args: [{
imports: [
CommonModule,
ReactiveFormsModule,
RouterModule,
HttpClientModule,
FormsModule,
NgxsModule.forFeature([EventListenerState, LoaderState]),
],
declarations: [
AbstractNgModelComponent,
RouterOutletComponent,
AutosizeDirective,
AutofocusDirective,
EllipsisDirective,
ForDirective,
HighlightDirective,
ScrollListenerDirective,
],
exports: [
CommonModule,
HttpClientModule,
FormsModule,
NgxsModule,
ReactiveFormsModule,
RouterModule,
AbstractNgModelComponent,
RouterOutletComponent,
AutosizeDirective,
AutofocusDirective,
EllipsisDirective,
ForDirective,
HighlightDirective,
ScrollListenerDirective,
TextMaskModule,
],
},] }
];
return CoreModule;
}());
/**
* @return {?}
*/
function noop() {
/** @type {?} */
var noop = (/**
* @return {?}
*/
function () { });
return noop;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
export { AbstractNgModelComponent, EventListenerPublish, EventListenerAdd, EventListenerScrollVertical, EventListenerRemove, LoaderSetProgress, RouterOutletComponent, LOADER_DEFAULTS, AutofocusDirective, AutosizeDirective, EllipsisDirective, ForDirective, HighlightDirective, ScrollListenerDirective, EventHandler, EventListener, LazyLoadScriptService, EventListenerState, LoaderState, ngxsLogExcept, notNull, transformToArray, transformByRegex, uuid, fromFork, takeUntilNotNull, takeUntilDestroy, normalizeDiacritics, noop, CoreModule, AbstractNgModelComponent as ɵh, EventListenerAdd as ɵb, EventListenerPublish as ɵc, EventListenerRemove as ɵd, LoaderSetProgress as ɵg, RouterOutletComponent as ɵi, LOADER_DEFAULTS as ɵf, AutofocusDirective as ɵk, AutosizeDirective as ɵj, EllipsisDirective as ɵl, ForDirective as ɵm, HighlightDirective as ɵn, ScrollListenerDirective as ɵo, EventHandler as ɵp, EventListenerState as ɵa, LoaderState as ɵe };
//# sourceMappingURL=ngx-performance-ui-core.js.map