@ngx-performance-ui/core
Version:
Ngx Performance UI - Core
1,582 lines (1,548 loc) • 60.8 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('just-compare'), require('text-mask-core/dist/textMaskCore'), require('rxjs'), require('rxjs/operators'), require('@angular/common'), require('@angular/common/http'), require('@angular/core'), require('@angular/forms'), require('@angular/router'), require('@ngxs/store'), require('angular2-text-mask')) :
typeof define === 'function' && define.amd ? define('@ngx-performance-ui/core', ['exports', 'just-compare', 'text-mask-core/dist/textMaskCore', 'rxjs', 'rxjs/operators', '@angular/common', '@angular/common/http', '@angular/core', '@angular/forms', '@angular/router', '@ngxs/store', 'angular2-text-mask'], factory) :
(factory((global['ngx-performance-ui'] = global['ngx-performance-ui'] || {}, global['ngx-performance-ui'].core = {}),global.compare,global.textMaskCore,global.rxjs,global.rxjs.operators,global.ng.common,global.ng.common.http,global.ng.core,global.ng.forms,global.ng.router,global.i1$1,global.angular2TextMask));
}(this, (function (exports,compare,textMaskCore,rxjs,operators,i1,http,i0,forms,router,i1$1,angular2TextMask) { 'use strict';
compare = compare && compare.hasOwnProperty('default') ? compare['default'] : compare;
/**
* @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(i0.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: i0.Component, args: [{ template: '' }] }
];
/** @nocollapse */
AbstractNgModelComponent.ctorParameters = function () {
return [
{ type: i0.Injector }
];
};
AbstractNgModelComponent.propDecorators = {
disabled: [{ type: i0.Input }],
id: [{ type: i0.Input }],
ngModel: [{ type: i0.Input }],
valueFn: [{ type: i0.Input }],
valueLimitFn: [{ type: i0.Input }],
value: [{ type: i0.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: i0.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: i0.Directive, args: [{
selector: '[autofocus]',
},] }
];
/** @nocollapse */
AutofocusDirective.ctorParameters = function () {
return [
{ type: i0.ElementRef }
];
};
AutofocusDirective.propDecorators = {
enable: [{ type: i0.Input, args: ['autofocus',] }],
delay: [{ type: i0.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: i0.Directive, args: [{
selector: '[autosize]',
},] }
];
/** @nocollapse */
AutosizeDirective.ctorParameters = function () {
return [
{ type: i0.ElementRef }
];
};
AutosizeDirective.propDecorators = {
enabled: [{ type: i0.Input, args: ['autosize',] }],
onInput: [{ type: i0.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: i0.Directive, args: [{
selector: '[pEllipsis]',
},] }
];
/** @nocollapse */
EllipsisDirective.ctorParameters = function () {
return [
{ type: i0.ElementRef }
];
};
EllipsisDirective.propDecorators = {
pEllipsis: [{ type: i0.Input }],
maxWidth: [{ type: i0.HostBinding, args: ['style.max-width',] }],
title: [{ type: i0.HostBinding, args: ['title',] }, { type: i0.Input }],
pEllipsisEnabled: [{ type: i0.HostBinding, args: ['class.p-ellipsis',] }, { type: i0.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 i1.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: i0.Directive, args: [{
selector: '[pFor]',
},] }
];
/** @nocollapse */
ForDirective.ctorParameters = function () {
return [
{ type: i0.IterableDiffers },
{ type: i0.TemplateRef },
{ type: i0.ViewContainerRef }
];
};
ForDirective.propDecorators = {
items: [{ type: i0.Input, args: ['pForOf',] }],
trackBy: [{ type: i0.Input, args: ['pForTrackBy',] }],
filterKey: [{ type: i0.Input, args: ['pForFilterKey',] }],
filterValue: [{ type: i0.Input, args: ['pForFilterValue',] }],
filterContain: [{ type: i0.Input, args: ['pForFilterContain',] }],
compareBy: [{ type: i0.Input, args: ['pForCompareBy',] }],
containCompareBy: [{ type: i0.Input, args: ['pForContainCompareBy',] }]
};
return ForDirective;
}());
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/**
* @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 = textMaskCore.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 rxjs.forkJoin.apply(void 0, __spread(streams.map(( /**
* @param {?} stream
* @return {?}
*/function (stream) { return stream.pipe(operators.take(1)); }))));
}
/**
* @template T
* @param {?} destroy$
* @return {?}
*/
function takeUntilNotNull(destroy$) {
return rxjs.pipe(operators.filter(notNull), operators.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 rxjs.Subject();
proto.ngOnDestroy = ( /**
* @return {?}
*/function () {
onDestroy.apply(this, arguments);
destroy$.next();
destroy$.complete();
});
return operators.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: i0.Directive, args: [{
selector: '[pHighlight]',
},] }
];
/** @nocollapse */
HighlightDirective.ctorParameters = function () {
return [
{ type: i0.ElementRef },
{ type: i0.Renderer2 }
];
};
HighlightDirective.propDecorators = {
pHighlight: [{ type: i0.Input }],
class: [{ type: i0.Input, args: ['pHighlightClass',] }],
hide: [{ type: i0.Input, args: ['pHighlightHide',] }],
hideWhenNull: [{ type: i0.Input, args: ['pHighlightHideWhenNull',] }],
hideClass: [{ type: i0.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 rxjs.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(operators.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: i0.Directive, args: [{ selector: 'perfect-scrollbar' },] }
];
/** @nocollapse */
ScrollListenerDirective.ctorParameters = function () {
return [
{ type: i1$1.Store }
];
};
ScrollListenerDirective.propDecorators = {
publish: [{ type: i0.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: i0.Injectable, args: [{
providedIn: 'root',
},] }
];
/** @nocollapse */
EventHandler.ctorParameters = function () {
return [
{ type: i1$1.Store }
];
};
/** @nocollapse */ EventHandler.ngInjectableDef = i0.defineInjectable({ factory: function EventHandler_Factory() { return new EventHandler(i0.inject(i1$1.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
*/
(function (EventListener) {
/**
* @record
*/
function State() { }
EventListener.State = State;
EventListener.debonceTimes = {
click: 300,
mousemove: 500,
resize: 700,
keyup: 300,
};
})(exports.EventListener || (exports.EventListener = {}));
/**
* @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 rxjs.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: i0.Injectable, args: [{
providedIn: 'root',
},] }
];
/** @nocollapse */
LazyLoadScriptService.ctorParameters = function () {
return [
{ type: undefined, decorators: [{ type: i0.Inject, args: [i1.DOCUMENT,] }] }
];
};
/** @nocollapse */ LazyLoadScriptService.ngInjectableDef = i0.defineInjectable({ factory: function LazyLoadScriptService_Factory() { return new LazyLoadScriptService(i0.inject(i1.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 = i1$1.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] = rxjs.fromEvent(key === 'resize' ? window : document, key)
.pipe(operators.debounceTime(exports.EventListener.debonceTimes[key] || 300), operators.share())
.subscribe(( /**