@ngx-performance-ui/core/fesm2015/ngx-performance-ui-core.js

Ngx Performance UI - Core

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 } 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
 */
class AbstractNgModelComponent {
    /**
     * @param {?} injector
     */
    constructor(injector) {
        this.injector = injector;
        this.valueFn = (/**
         * @param {?} value
         * @return {?}
         */
        value => (/** @type {?} */ (((/** @type {?} */ (value))))));
        this.valueLimitFn = (/**
         * @param {?} value
         * @return {?}
         */
        value => false);
        this.cdRef = injector.get(ChangeDetectorRef);
    }
    /**
     * @param {?} value
     * @return {?}
     */
    set value(value) {
        value = this.valueFn((/** @type {?} */ (((/** @type {?} */ (value))))), this._value);
        if (this.valueLimitFn(value, this._value) !== false)
            return;
        this._value = value;
        this.notifyValueChange();
    }
    /**
     * @return {?}
     */
    get value() {
        return this._value || this.defaultValue;
    }
    /**
     * @return {?}
     */
    get defaultValue() {
        return this._value;
    }
    /**
     * @return {?}
     */
    notifyValueChange() {
        if (this.onChange) {
            this.onChange(this.value);
        }
    }
    /**
     * @param {?} value
     * @return {?}
     */
    writeValue(value) {
        this._value = this.valueLimitFn(value, this._value) || value;
        setTimeout((/**
         * @return {?}
         */
        () => this.cdRef.detectChanges()), 0);
    }
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnChange(fn) {
        this.onChange = fn;
    }
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnTouched(fn) {
        this.onTouched = fn;
    }
    /**
     * @param {?} isDisabled
     * @return {?}
     */
    setDisabledState(isDisabled) {
        this.disabled = isDisabled;
    }
}
AbstractNgModelComponent.decorators = [
    { type: Component, args: [{ template: '' }] }
];
/** @nocollapse */
AbstractNgModelComponent.ctorParameters = () => [
    { type: Injector }
];
AbstractNgModelComponent.propDecorators = {
    disabled: [{ type: Input }],
    id: [{ type: Input }],
    ngModel: [{ type: Input }],
    valueFn: [{ type: Input }],
    valueLimitFn: [{ type: Input }],
    value: [{ type: Input }]
};

/**
 * @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
 */
class EventListenerPublish {
    /**
     * @param {?} payload
     */
    constructor(payload) {
        this.payload = payload;
    }
}
EventListenerPublish.type = '[EventListener] Publish';
class EventListenerAdd {
    /**
     * @param {?} payload
     */
    constructor(payload) {
        this.payload = payload;
    }
}
EventListenerAdd.type = '[EventListener] Add';
class EventListenerScrollVertical {
    /**
     * @param {?} payload
     */
    constructor(payload) {
        this.payload = payload;
    }
}
EventListenerScrollVertical.type = '[EventListener] Scroll Vertical';
class EventListenerRemove {
    /**
     * @param {?} payload
     */
    constructor(payload) {
        this.payload = payload;
    }
}
EventListenerRemove.type = '[EventListener] Remove';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class LoaderSetProgress {
    /**
     * @param {?} payload
     */
    constructor(payload) {
        this.payload = payload;
    }
}
LoaderSetProgress.type = '[Loader] Set Progress';

/**
 * @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
 */
class RouterOutletComponent {
}
RouterOutletComponent.decorators = [
    { type: Component, args: [{
                selector: 'p-router-outlet',
                template: `
    <router-outlet></router-outlet>
  `
            }] }
];

/**
 * @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 {?} */
const 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
 */
class AutofocusDirective {
    /**
     * @param {?} elRef
     */
    constructor(elRef) {
        this.elRef = elRef;
        this.enable = false;
        this.delay = 0;
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        if (this.enable)
            setTimeout((/**
             * @return {?}
             */
            () => this.elRef.nativeElement.focus()), this.delay);
    }
}
AutofocusDirective.decorators = [
    { type: Directive, args: [{
                selector: '[autofocus]',
            },] }
];
/** @nocollapse */
AutofocusDirective.ctorParameters = () => [
    { type: ElementRef }
];
AutofocusDirective.propDecorators = {
    enable: [{ type: Input, args: ['autofocus',] }],
    delay: [{ type: Input, args: ['autofocusDelay',] }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class AutosizeDirective {
    /**
     * @param {?} element
     */
    constructor(element) {
        this.element = element;
        this.enabled = true;
    }
    /**
     * @return {?}
     */
    onInput() {
        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 {?}
     */
    ngAfterContentInit() {
        this.onInput();
    }
}
AutosizeDirective.decorators = [
    { type: Directive, args: [{
                selector: '[autosize]',
            },] }
];
/** @nocollapse */
AutosizeDirective.ctorParameters = () => [
    { type: ElementRef }
];
AutosizeDirective.propDecorators = {
    enabled: [{ type: Input, args: ['autosize',] }],
    onInput: [{ type: HostListener, args: ['input',] }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class EllipsisDirective {
    /**
     * @param {?} elRef
     */
    constructor(elRef) {
        this.elRef = elRef;
        this.pEllipsisEnabled = true;
    }
    /**
     * @return {?}
     */
    get maxWidth() {
        return this.pEllipsis || '100%';
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        setTimeout((/**
         * @return {?}
         */
        () => {
            this.title = this.title || ((/** @type {?} */ (this.elRef.nativeElement))).innerText;
        }), 0);
    }
}
EllipsisDirective.decorators = [
    { type: Directive, args: [{
                selector: '[pEllipsis]',
            },] }
];
/** @nocollapse */
EllipsisDirective.ctorParameters = () => [
    { 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 }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 */
class RecordViewTuple {
    /**
     * @param {?} record
     * @param {?} view
     */
    constructor(record, view) {
        this.record = record;
        this.view = view;
    }
}
class ForDirective {
    /**
     * @param {?} iterable
     * @param {?} tempRef
     * @param {?} vcRef
     */
    constructor(iterable, tempRef, vcRef) {
        this.iterable = iterable;
        this.tempRef = tempRef;
        this.vcRef = vcRef;
    }
    /**
     * @return {?}
     */
    get compareFn() {
        return this.compareBy || compare;
    }
    /**
     * @return {?}
     */
    get containCompareFn() {
        return (this.containCompareBy ||
            ((/**
             * @param {?} value
             * @param {?} comparision
             * @return {?}
             */
            (value, comparision) => value.toLocaleLowerCase().indexOf(comparision.toLocaleLowerCase()) > -1)));
    }
    /**
     * @return {?}
     */
    get trackByFn() {
        return this.trackBy || ((/**
         * @param {?} index
         * @param {?=} item
         * @return {?}
         */
        (index, item = {}) => item.id || index));
    }
    /**
     * @private
     * @param {?} changes
     * @param {?} items
     * @return {?}
     */
    applyChanges(changes, items) {
        /** @type {?} */
        const insertTuples = [];
        changes.forEachOperation((/**
         * @param {?} item
         * @param {?} adjustedPreviousIndex
         * @param {?} currentIndex
         * @return {?}
         */
        (item, adjustedPreviousIndex, currentIndex) => {
            if (item.previousIndex == null) {
                /** @type {?} */
                const view = this.vcRef.createEmbeddedView(this.tempRef, new NgForOfContext((/** @type {?} */ (null)), items, -1, -1), currentIndex);
                /** @type {?} */
                const tuple = new RecordViewTuple(item, view);
                insertTuples.push(tuple);
            }
            else if (currentIndex == null) {
                this.vcRef.remove(adjustedPreviousIndex);
            }
            else {
                /** @type {?} */
                const view = (/** @type {?} */ (this.vcRef.get(adjustedPreviousIndex)));
                this.vcRef.move(view, currentIndex);
                /** @type {?} */
                const tuple = new RecordViewTuple(item, (/** @type {?} */ (view)));
                insertTuples.push(tuple);
            }
        }));
        for (let i = 0; i < insertTuples.length; i++) {
            insertTuples[i].view.context.$implicit = insertTuples[i].record.item;
        }
        for (let i = 0, ilen = this.vcRef.length; i < ilen; i++) {
            /** @type {?} */
            const viewRef = (/** @type {?} */ (this.vcRef.get(i)));
            viewRef.context.index = i;
            viewRef.context.count = ilen;
            viewRef.context.ngForOf = items;
        }
        changes.forEachIdentityChange((/**
         * @param {?} record
         * @return {?}
         */
        (record) => {
            /** @type {?} */
            const viewRef = (/** @type {?} */ (this.vcRef.get(record.currentIndex)));
            viewRef.context.$implicit = record.item;
        }));
    }
    /**
     * @return {?}
     */
    ngOnChanges() {
        if (!Array.isArray(this.items))
            throw 'pForOf must be an array!';
        /** @type {?} */
        let items = [];
        if (this.filterValue !== undefined) {
            /** @type {?} */
            let compareFn;
            if (this.filterContain) {
                if (typeof this.filterValue !== 'string') {
                    throw 'filterValue must be a string when filterContain is true';
                }
                compareFn = this.containCompareFn;
            }
            else {
                compareFn = this.compareFn;
            }
            items = this.items.filter((/**
             * @param {?} item
             * @return {?}
             */
            item => compareFn(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 {?} */
            const changes = this.iterableDiffer.diff(items);
            if (changes)
                this.applyChanges(changes, items);
        }
    }
}
ForDirective.decorators = [
    { type: Directive, args: [{
                selector: '[pFor]',
            },] }
];
/** @nocollapse */
ForDirective.ctorParameters = () => [
    { 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',] }]
};

/**
 * @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 {?} */
    const NO_LOG = new RegExp('\\[(' + states.join('|') + ')\\]');
    return Object.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, ...args) {
            if (this.silent)
                return;
            console.log(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 {?} */
    const inputElement = document.createElement('input');
    inputElement.type = 'text';
    /** @type {?} */
    const textMaskInputElement = createTextMaskInputElement(Object.assign({}, mask, { 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(...streams) {
    return forkJoin(...streams.map((/**
     * @param {?} stream
     * @return {?}
     */
    stream => 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 {?} */
    const proto = Object.getPrototypeOf(component);
    /** @type {?} */
    const 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 {?} */
    const 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 {?} */
const 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 {?} */
const 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 {?}
     */
    match => 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
 */
class HighlightDirective {
    /**
     * @param {?} elRef
     * @param {?} renderer
     */
    constructor(elRef, renderer) {
        this.elRef = elRef;
        this.renderer = renderer;
        this.value = '';
        this.class = 'text-primary';
        this.hide = false;
        this.hideWhenNull = false;
        this.hideClass = 'd-none';
    }
    /**
     * @param {?} value
     * @return {?}
     */
    set pHighlight(value) {
        if (!value && value !== '' && typeof value !== 'string')
            return;
        this.value = normalizeDiacritics(value.replace(/\s+/gm, ' '));
    }
    /**
     * @private
     * @param {?} text
     * @return {?}
     */
    setHighlight(text) {
        if (!this.value || this.value === '' || this.value === ' ')
            return text;
        text = normalizeDiacritics(text.replace(/\s+/gm, ' '));
        /** @type {?} */
        const splitText = text.split(' ').filter((/**
         * @param {?} value
         * @return {?}
         */
        value => value !== ''));
        /** @type {?} */
        const splitValue = this.value.split(' ').filter((/**
         * @param {?} value
         * @return {?}
         */
        value => value !== ''));
        /** @type {?} */
        let found = [];
        splitValue.forEach((/**
         * @param {?} value
         * @return {?}
         */
        value => {
            found = [
                ...found,
                ...splitText
                    .map((/**
                 * @param {?} text
                 * @param {?} index
                 * @return {?}
                 */
                (text, index) => ({ text, index, value })))
                    .filter((/**
                 * @param {?} __0
                 * @return {?}
                 */
                ({ text }) => text.toLocaleLowerCase().indexOf(value.toLocaleLowerCase()) > -1)),
            ];
        }));
        if (!found.length)
            return text;
        return splitText.reduce((/**
         * @param {?} acc
         * @param {?} val
         * @param {?} index
         * @return {?}
         */
        (acc, val, index) => {
            const { value } = found.find((/**
             * @param {?} data
             * @return {?}
             */
            data => data.index === index)) || ((/** @type {?} */ ({})));
            if (value) {
                /** @type {?} */
                const text = val.substr(val.toLocaleLowerCase().indexOf(value.toLocaleLowerCase()), value.length);
                val = val.replace(RegExp(value, 'mig'), `<span class="${this.class}">${text}</span>`);
            }
            return (acc += `${val} `);
        }), '');
    }
    /**
     * @return {?}
     */
    ngOnChanges() {
        setTimeout((/**
         * @return {?}
         */
        () => {
            /** @type {?} */
            const element = (/** @type {?} */ (this.elRef.nativeElement));
            /** @type {?} */
            const text = element.textContent;
            if (!text)
                return;
            this.renderer.removeClass(element, this.hideClass);
            /** @type {?} */
            const 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 = () => [
    { 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',] }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ScrollListenerDirective {
    /**
     * @param {?} store
     */
    constructor(store) {
        this.store = store;
        this.dispatch$ = new Subject();
    }
    /**
     * @param {?} event
     * @return {?}
     */
    publish(event) {
        this.dispatch$.next(event);
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.dispatch$
            .pipe(debounceTime(300), takeUntilDestroy(this))
            .subscribe((/**
         * @param {?} event
         * @return {?}
         */
        event => this.store.dispatch(new EventListenerScrollVertical(event))));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() { }
}
ScrollListenerDirective.decorators = [
    { type: Directive, args: [{ selector: 'perfect-scrollbar' },] }
];
/** @nocollapse */
ScrollListenerDirective.ctorParameters = () => [
    { type: Store }
];
ScrollListenerDirective.propDecorators = {
    publish: [{ type: HostListener, args: ['psScrollY', ['$event'],] }]
};

/**
 * @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
 */
class EventHandler {
    /**
     * @param {?} store
     */
    constructor(store) {
        this.store = store;
        setTimeout((/**
         * @return {?}
         */
        () => {
            this.store.dispatch(new EventListenerAdd(['click', 'keyup', 'mousemove']));
        }), 0);
    }
}
EventHandler.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root',
            },] }
];
/** @nocollapse */
EventHandler.ctorParameters = () => [
    { type: Store }
];
/** @nocollapse */ EventHandler.ngInjectableDef = defineInjectable({ factory: function EventHandler_Factory() { return new EventHandler(inject(Store)); }, token: EventHandler, providedIn: "root" });

/**
 * @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
 */
class LazyLoadScriptService {
    /**
     * @param {?} document
     */
    constructor(document) {
        this.document = document;
        this._loadedLibraries = {};
    }
    /**
     * @param {?} url
     * @return {?}
     */
    loadScript(url) {
        if (this._loadedLibraries[url]) {
            return this._loadedLibraries[url].asObservable();
        }
        this._loadedLibraries[url] = new ReplaySubject();
        /** @type {?} */
        const script = this.document.createElement('script');
        script.type = 'text/javascript';
        script.src = url;
        script.onload = (/**
         * @return {?}
         */
        () => {
            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 = () => [
    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
/** @nocollapse */ LazyLoadScriptService.ngInjectableDef = defineInjectable({ factory: function LazyLoadScriptService_Factory() { return new LazyLoadScriptService(inject(DOCUMENT)); }, token: LazyLoadScriptService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

var EventListenerState_1;
let EventListenerState = EventListenerState_1 = class EventListenerState {
    constructor() {
        this.subscriptions = {};
    }
    /**
     * @param {?} state
     * @return {?}
     */
    static getAll(state) {
        return state;
    }
    /**
     * @param {?} key
     * @return {?}
     */
    static getOne(key) {
        /** @type {?} */
        const selector = createSelector([EventListenerState_1], (/**
         * @param {?} state
         * @return {?}
         */
        function (state) {
            return state[key];
        }));
        return selector;
    }
    /**
     * @param {?} __0
     * @param {?} __1
     * @return {?}
     */
    addEventListener({ dispatch }, { payload }) {
        transformToArray(payload).forEach((/**
         * @param {?} key
         * @return {?}
         */
        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 {?}
             */
            event => dispatch(new EventListenerPublish(event))));
        }));
    }
    /**
     * @param {?} __0
     * @param {?} __1
     * @return {?}
     */
    publishEvent({ patchState }, { payload }) {
        patchState({ [payload.type]: payload });
    }
    /**
     * @param {?} __0
     * @param {?} __1
     * @return {?}
     */
    removeEventListener({ patchState }, { payload }) {
        transformToArray(payload).forEach((/**
         * @param {?} key
         * @return {?}
         */
        key => {
            if (this.subscriptions[key]) {
                this.subscriptions[key].unsubscribe();
                delete this.subscriptions[key];
                patchState({
                    [key]: null,
                });
            }
        }));
    }
};
__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);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
let LoaderState = class LoaderState {
    /**
     * @param {?} __0
     * @return {?}
     */
    static progress({ progress }) {
        return progress;
    }
    /**
     * @param {?} __0
     * @param {?} __1
     * @return {?}
     */
    addEventListener({ patchState }, { 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);

/**
 * @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
 */
class CoreModule {
    /**
     * @return {?}
     */
    static forRoot() {
        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 {?}
 */
function noop() {
    /** @type {?} */
    const 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