slick-components 4.4.13 → 4.4.16

package/esm2020/slick-validation-indicator/slick-validation-indicator.directive.mjs

@@ -0,0 +1,63 @@
+import { Directive, Input } from "@angular/core";
+import * as i0 from "@angular/core";
+export var SlickValidationTypes;
+(function (SlickValidationTypes) {
+    SlickValidationTypes[SlickValidationTypes["None"] = 0] = "None";
+    SlickValidationTypes[SlickValidationTypes["Error"] = 1] = "Error";
+    SlickValidationTypes[SlickValidationTypes["Warning"] = 2] = "Warning";
+})(SlickValidationTypes || (SlickValidationTypes = {}));
+export class SlickValidationIndicatorDirective {
+    constructor(el) {
+        this.el = el;
+        this.validationType = SlickValidationTypes.Warning;
+        this.bgWarningStyle = "#ffc207";
+        this.bgDangerStyle = "#dc3545";
+        this.bgSuccessStyle = "#28a745";
+        this.originalBorderStyle = this.el.nativeElement.style.borderLeft;
+    }
+    ngOnInit() {
+        if (this.validationType) {
+            if (this.validationType.toString().toLowerCase() === 'warning')
+                this.validationType = SlickValidationTypes.Warning;
+            else if (this.validationType.toString().toLowerCase() === 'none')
+                this.validationType = SlickValidationTypes.None;
+            else
+                this.validationType = SlickValidationTypes.Error;
+        }
+        this.setIndicator();
+    }
+    ngOnChanges(changes) {
+        this.setIndicator();
+    }
+    setIndicator() {
+        if (this.validationType === SlickValidationTypes.None) {
+            this.el.nativeElement.style.borderLeft = this.originalBorderStyle;
+        }
+        else {
+            if (this.isValid) {
+                this.el.nativeElement.style.borderLeft = "6px solid " + this.bgSuccessStyle;
+            }
+            else {
+                if (this.validationType === SlickValidationTypes.Warning)
+                    this.el.nativeElement.style.borderLeft = "6px solid " + this.bgWarningStyle;
+                else
+                    this.el.nativeElement.style.borderLeft = "6px solid " + this.bgDangerStyle;
+            }
+        }
+    }
+}
+/** @nocollapse */ SlickValidationIndicatorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickValidationIndicatorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickValidationIndicatorDirective, selector: "[slick-validation-indicator]", inputs: { isValid: ["slick-validation-indicator", "isValid"], validationType: ["slickValidationType", "validationType"] }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slick-validation-indicator]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { isValid: [{
+                type: Input,
+                args: ["slick-validation-indicator"]
+            }], validationType: [{
+                type: Input,
+                args: ["slickValidationType"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/slick-validation-indicator/slick-validation-indicator.module.mjs

@@ -0,0 +1,19 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from "@angular/core";
+import { SlickValidationIndicatorDirective, SlickValidationTypes } from "./slick-validation-indicator.directive";
+import * as i0 from "@angular/core";
+export class SlickValidationIndicatorModule {
+}
+/** @nocollapse */ SlickValidationIndicatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickValidationIndicatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorModule, declarations: [SlickValidationIndicatorDirective], imports: [CommonModule], exports: [CommonModule, SlickValidationIndicatorDirective] });
+/** @nocollapse */ SlickValidationIndicatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorModule, imports: [[CommonModule], CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickValidationIndicatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [SlickValidationIndicatorDirective],
+                    exports: [CommonModule, SlickValidationIndicatorDirective]
+                }]
+        }] });
+export { SlickValidationIndicatorDirective, SlickValidationTypes };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stdmFsaWRhdGlvbi1pbmRpY2F0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvc2xpY2stdmFsaWRhdGlvbi1pbmRpY2F0b3Ivc2xpY2stdmFsaWRhdGlvbi1pbmRpY2F0b3IubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxpQ0FBaUMsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDOztBQU9qSCxNQUFNLE9BQU8sOEJBQThCOzs4SUFBOUIsOEJBQThCOytJQUE5Qiw4QkFBOEIsaUJBSDNCLGlDQUFpQyxhQUR0QyxZQUFZLGFBRVosWUFBWSxFQUFFLGlDQUFpQzsrSUFFN0MsOEJBQThCLFlBSmpDLENBQUMsWUFBWSxDQUFDLEVBRWIsWUFBWTsyRkFFViw4QkFBOEI7a0JBTDFDLFFBQVE7bUJBQUM7b0JBQ1QsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixZQUFZLEVBQUUsQ0FBQyxpQ0FBaUMsQ0FBQztvQkFDakQsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGlDQUFpQyxDQUFDO2lCQUMxRDs7QUFFRCxPQUFPLEVBQUUsaUNBQWlDLEVBQUUsb0JBQW9CLEVBQUUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgU2xpY2tWYWxpZGF0aW9uSW5kaWNhdG9yRGlyZWN0aXZlLCBTbGlja1ZhbGlkYXRpb25UeXBlcyB9IGZyb20gXCIuL3NsaWNrLXZhbGlkYXRpb24taW5kaWNhdG9yLmRpcmVjdGl2ZVwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcclxuXHRkZWNsYXJhdGlvbnM6IFtTbGlja1ZhbGlkYXRpb25JbmRpY2F0b3JEaXJlY3RpdmVdLFxyXG5cdGV4cG9ydHM6IFtDb21tb25Nb2R1bGUsIFNsaWNrVmFsaWRhdGlvbkluZGljYXRvckRpcmVjdGl2ZV1cclxufSlcclxuZXhwb3J0IGNsYXNzIFNsaWNrVmFsaWRhdGlvbkluZGljYXRvck1vZHVsZSB7IH1cclxuZXhwb3J0IHsgU2xpY2tWYWxpZGF0aW9uSW5kaWNhdG9yRGlyZWN0aXZlLCBTbGlja1ZhbGlkYXRpb25UeXBlcyB9XHJcbiJdfQ==

package/esm2020/utils/slick-function-lock.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+class SlickFunctionLockModel {
+    constructor() {
+        this.infiniteLoopCheck = 100;
+    }
+}
+export class SlickFunctionLockService {
+    constructor() {
+        this.functionLocks = {};
+    }
+    lock(functionKey, iterationTimeout = 200) {
+        if (!this.functionLocks[functionKey])
+            this.functionLocks[functionKey] = [];
+        const functionLock = new SlickFunctionLockModel();
+        functionLock.functionKey = functionKey;
+        let d = new Date().getTime();
+        const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = (d + Math.random() * 16) % 16 | 0;
+            d = Math.floor(d / 16);
+            return (c == 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+        functionLock.uuid = uuid;
+        functionLock.lockCount = this.functionLocks[functionKey].length + 1;
+        functionLock.promise = new Promise((resolve, reject) => {
+            functionLock.intervalId = setInterval(() => {
+                if (functionLock.lockCount === 1 || functionLock.infiniteLoopCheck-- === 0) {
+                    clearInterval(functionLock.intervalId);
+                    if (functionLock.infiniteLoopCheck === 0) {
+                        alert("Inifite loop detected for " + functionLock.functionKey);
+                    }
+                    resolve(null);
+                }
+            }, iterationTimeout);
+        });
+        this.functionLocks[functionKey].push(functionLock);
+        return functionLock.promise;
+    }
+    release(functionKey) {
+        if (this.functionLocks && this.functionLocks[functionKey]) {
+            this.functionLocks[functionKey].splice(0, 1);
+            this.functionLocks[functionKey].forEach((fl) => fl.lockCount--);
+            return this.functionLocks[functionKey].length;
+        }
+        else {
+            return -1;
+        }
+    }
+}
+/** @nocollapse */ SlickFunctionLockService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFunctionLockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickFunctionLockService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFunctionLockService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFunctionLockService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/slick-init.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class SlickInitParams {
+    constructor() {
+        this.errorLog = "minimal";
+    }
+}
+export class SlickInitService {
+    constructor() { }
+    static init(initParams) {
+        console.info(`Slick Components Version ${SlickInitService.version}`);
+        initParams.version = SlickInitService.version;
+        window.slickComponentsParams = initParams;
+        return window.slickComponentsParams;
+    }
+    static getParams() {
+        if (!window.slickComponentsParams) {
+            const defaultParams = new SlickInitParams();
+            defaultParams.attachTo = "body";
+            window.slickComponentsParams = defaultParams;
+        }
+        return window.slickComponentsParams;
+    }
+    static getAttachTo() {
+        return SlickInitService.getParams().attachTo;
+    }
+    static setAttachTo(attachToElement) {
+        SlickInitService.getParams().attachTo = attachToElement;
+    }
+    static getPlatform() {
+        return SlickInitService.getParams().platform;
+    }
+    static setPlatform(platform) {
+        SlickInitService.getParams().platform = platform;
+    }
+    static getErrorLog() {
+        return SlickInitService.getParams().errorLog;
+    }
+    static setErrorLog(errorLog) {
+        SlickInitService.getParams().errorLog = errorLog;
+    }
+}
+SlickInitService.version = "4.4.16";
+/** @nocollapse */ SlickInitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickInitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickInitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickInitService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickInitService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/slick-log.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @dynamic
+export class SlickLogService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async writeLog(text) {
+        const params = {
+            text: text,
+            logDate: new Date()
+        };
+        await (this.httpClient.post("https://api.crflow.com/debuglogs/writelog", params).toPromise());
+    }
+    ;
+}
+/** @nocollapse */ SlickLogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickLogService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickLogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickLogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickLogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stbG9nLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy91dGlscy9zbGljay1sb2cuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFjLE1BQU0sZUFBZSxDQUFDOzs7QUFHdkQsV0FBVztBQUVYLE1BQU0sT0FBTyxlQUFlO0lBQzNCLFlBQW9CLFVBQXNCO1FBQXRCLGVBQVUsR0FBVixVQUFVLENBQVk7SUFBSSxDQUFDO0lBRS9DLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBWTtRQUMxQixNQUFNLE1BQU0sR0FBRztZQUNkLElBQUksRUFBRSxJQUFJO1lBQ1YsT0FBTyxFQUFFLElBQUksSUFBSSxFQUFFO1NBQ25CLENBQUE7UUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsMkNBQTJDLEVBQUUsTUFBTSxDQUFDLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUMvRixDQUFDO0lBQUEsQ0FBQzs7K0hBVlUsZUFBZTttSUFBZixlQUFlOzJGQUFmLGVBQWU7a0JBRDNCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBFbGVtZW50UmVmIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gXCJAYW5ndWxhci9jb21tb24vaHR0cFwiO1xyXG5cclxuLy8gQGR5bmFtaWNcclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgU2xpY2tMb2dTZXJ2aWNlIHtcclxuXHRjb25zdHJ1Y3Rvcihwcml2YXRlIGh0dHBDbGllbnQ6IEh0dHBDbGllbnQpIHsgfVxyXG5cclxuXHRhc3luYyB3cml0ZUxvZyh0ZXh0OiBzdHJpbmcpOiBQcm9taXNlPGFueT4ge1xyXG5cdFx0Y29uc3QgcGFyYW1zID0ge1xyXG5cdFx0XHR0ZXh0OiB0ZXh0LFxyXG5cdFx0XHRsb2dEYXRlOiBuZXcgRGF0ZSgpXHJcblx0XHR9XHJcblxyXG5cdFx0YXdhaXQgKHRoaXMuaHR0cENsaWVudC5wb3N0KFwiaHR0cHM6Ly9hcGkuY3JmbG93LmNvbS9kZWJ1Z2xvZ3Mvd3JpdGVsb2dcIiwgcGFyYW1zKS50b1Byb21pc2UoKSk7IFxyXG5cdH07XHJcbn1cclxuXHJcbiJdfQ==

package/esm2020/utils/slick-sleep.service.mjs

@@ -0,0 +1,14 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+// @dynamic
+export class SlickSleepService {
+    static async sleep(timeout = 0) {
+        return new Promise((resolve) => setTimeout(() => resolve(), timeout));
+    }
+}
+/** @nocollapse */ SlickSleepService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickSleepService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickSleepService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickSleepService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickSleepService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stc2xlZXAuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL3V0aWxzL3NsaWNrLXNsZWVwLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBWSxNQUFNLGVBQWUsQ0FBQzs7QUFFckQsV0FBVztBQUVYLE1BQU0sT0FBTyxpQkFBaUI7SUFDN0IsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBa0IsQ0FBQztRQUNyQyxPQUFPLElBQUksT0FBTyxDQUFPLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUM3RSxDQUFDOztpSUFIVyxpQkFBaUI7cUlBQWpCLGlCQUFpQjsyRkFBakIsaUJBQWlCO2tCQUQ3QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuLy8gQGR5bmFtaWNcclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgU2xpY2tTbGVlcFNlcnZpY2Uge1xyXG5cdHN0YXRpYyBhc3luYyBzbGVlcCh0aW1lb3V0OiBudW1iZXIgPSAwKTogUHJvbWlzZTx2b2lkPiB7XHJcblx0XHRyZXR1cm4gbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUpID0+IHNldFRpbWVvdXQoKCkgPT4gcmVzb2x2ZSgpLCB0aW1lb3V0KSk7XHJcblx0fVxyXG59XHJcbiJdfQ==

package/esm2020/utils/slick-utils.service.mjs

@@ -0,0 +1,247 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+// @dynamic
+export class SlickUtilsService {
+    static newGuid() {
+        let d = new Date().getTime();
+        const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = (d + Math.random() * 16) % 16 | 0;
+            d = Math.floor(d / 16);
+            return (c == 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+        return uuid;
+    }
+    static waitForElement(elementSelector, iterationTimeout = 50) {
+        let infiniteLoopCheck = 10;
+        let iterationId;
+        const p = new Promise((resolve, reject) => {
+            iterationId = setInterval(() => {
+                const el = document.querySelector(elementSelector);
+                if (el) {
+                    clearInterval(iterationId);
+                    resolve(el);
+                }
+                if (--infiniteLoopCheck <= 0) {
+                    clearInterval(iterationId);
+                    alert("Loop Check failed trying to find " + elementSelector);
+                    reject();
+                }
+            }, 100);
+        });
+        return p;
+    }
+    static waitForElementRef(elementRef, iterationTimeout = 50) {
+        let infiniteLoopCheck = 10;
+        let iterationId;
+        const p = new Promise((resolve, reject) => {
+            iterationId = setInterval(() => {
+                const el = elementRef.nativeElement;
+                if (el && el.clientHeight && el.clientWidth) {
+                    clearInterval(iterationId);
+                    resolve(elementRef);
+                }
+                if (--infiniteLoopCheck <= 0) {
+                    clearInterval(iterationId);
+                    console.error("Loop Check failed trying to find element");
+                    reject();
+                }
+            }, iterationTimeout);
+        });
+        return p;
+    }
+    static getDeepObject(obj, objName) {
+        const dotSplit = objName.split(".");
+        let currentObj = obj;
+        dotSplit.forEach((o) => {
+            if (currentObj === null || currentObj === undefined)
+                return null;
+            currentObj = currentObj[o];
+        });
+        return currentObj;
+    }
+    static setDeepObject(obj, objName, val) {
+        const dotSplit = objName.split(".");
+        let prevObj = obj;
+        let currentObj = obj;
+        dotSplit.forEach((o) => {
+            if (currentObj === null || currentObj === undefined)
+                return null;
+            prevObj = currentObj;
+            currentObj = currentObj[o];
+        });
+        prevObj[dotSplit[dotSplit.length - 1]] = val;
+        return currentObj;
+    }
+    static clone(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        let returnObj = JSON.parse(JSON.stringify(obj));
+        //returnObj = this.dateSanitize(returnObj);
+        return returnObj;
+    }
+    static dateSanitize(obj, infiniteLoopCheck = 0) {
+        infiniteLoopCheck++;
+        if (infiniteLoopCheck > 20) {
+            console.error("infinte loop");
+            return obj;
+        }
+        if (obj === null || obj === undefined)
+            return obj;
+        // If the obj IS a date, return the processed date
+        if (typeof obj === "string" && /^([0-9]{4}-(0[1-9]|10|11|12)-([012][0-9]|30|31)T([01][0-9]|[2][0123]):([0-5][0-9]):([0-5][0-9])(.[0-9]{0,})?(z|Z))$/.test(obj))
+            return new Date(obj);
+        // If this is an atomic type (string, bool, number), just return the atomic object
+        if (typeof obj !== "object")
+            return obj;
+        let returnObj;
+        if (Array.isArray(obj)) {
+            returnObj = [];
+            obj.forEach(o => returnObj.push(this.dateSanitize(o, infiniteLoopCheck)));
+        }
+        else {
+            returnObj = {};
+            for (const key in obj) {
+                if (obj[key] === null)
+                    returnObj[key] = null;
+                else if (Array.isArray(obj[key])) {
+                    returnObj[key] = [];
+                    obj[key].forEach(o => returnObj[key].push(this.dateSanitize(o, infiniteLoopCheck)));
+                }
+                else if (typeof obj[key] === "object")
+                    returnObj[key] = this.dateSanitize(obj[key], ++infiniteLoopCheck);
+                else if (/^([0-9]{4}-(0[1-9]|10|11|12)-([012][0-9]|30|31)T([01][0-9]|[2][0123]):([0-5][0-9]):([0-5][0-9])(.[0-9]{0,})?(z|Z))$/.test(obj[key]))
+                    returnObj[key] = new Date(obj[key]);
+                else
+                    returnObj[key] = obj[key];
+            }
+        }
+        return returnObj;
+    }
+    static round(num, decimals) {
+        return Number(Math.round(parseFloat(num + 'e' + decimals)) + 'e-' + decimals);
+    }
+    static checkParentClassExists(el, className) {
+        let currentEl = el;
+        let hasSelector = false;
+        while (currentEl && currentEl !== document.body) {
+            if (currentEl.classList.contains(className)) {
+                hasSelector = true;
+                break;
+            }
+            currentEl = currentEl.parentElement;
+        }
+        return hasSelector;
+    }
+    static checkParentIdExists(el, idName) {
+        let currentEl = el;
+        let hasSelector = false;
+        while (currentEl && currentEl !== document.body) {
+            if (currentEl.getAttribute("id") === idName) {
+                hasSelector = true;
+                break;
+            }
+            currentEl = currentEl.parentElement;
+        }
+        return hasSelector;
+    }
+    static findParentByAttr(el, attrName, attrValue) {
+        let currentEl = el;
+        while (currentEl && currentEl !== document.body) {
+            if (currentEl.hasAttribute(attrName) && currentEl.getAttribute(attrName) === attrValue) {
+                return currentEl;
+            }
+            currentEl = currentEl.parentElement;
+        }
+        return null;
+    }
+    static findParent(el, className) {
+        let currentEl = el;
+        while (currentEl && currentEl !== document.body) {
+            if (currentEl.classList && currentEl.classList.contains(className)) {
+                return currentEl;
+            }
+            currentEl = currentEl.parentElement;
+        }
+        return null;
+    }
+    static getClosestSibling(el, className) {
+        let currentEl = el;
+        while (currentEl && currentEl !== document.body) {
+            if (currentEl.classList && currentEl.classList.contains(className)) {
+                return currentEl;
+            }
+            currentEl = currentEl.previousSibling;
+        }
+        return null;
+    }
+    static waitForTinyMCE(tinyMCEId) {
+        return new Promise((resolve, reject) => {
+            let waitForTinyMCE;
+            if (tinymce.get(tinyMCEId) && tinymce.get(tinyMCEId).initialized) {
+                resolve();
+            }
+            else {
+                clearInterval(waitForTinyMCE);
+                let infiniteLoopCheck = 100;
+                waitForTinyMCE = setInterval(() => {
+                    if ((tinymce.get(tinyMCEId) && tinymce.get(tinyMCEId).initialized) || infiniteLoopCheck === 0) {
+                        clearInterval(waitForTinyMCE);
+                        if (infiniteLoopCheck === 0) {
+                            console.error("Timed out waiting for tinyMCE Id: " + tinyMCEId);
+                            return reject();
+                        }
+                        else {
+                            return resolve();
+                        }
+                    }
+                    infiniteLoopCheck--;
+                }, 100);
+            }
+        });
+    }
+    static attachElement(el, attachTo) {
+        if (attachTo === 'body')
+            document.body.appendChild(el);
+        else {
+            const parent = document.body.querySelector(attachTo);
+            if (!parent) {
+                console.error("Could not find element " + attachTo + " to attach to");
+                return;
+            }
+            else {
+                parent.appendChild(el);
+            }
+        }
+    }
+    static removeElement(el) {
+        // it's okay if this fails.  It was already removed
+        try {
+            // the default destroy won't get rid of this
+            document.body.removeChild(el);
+        }
+        catch { }
+    }
+    static arrayInsert(elementToInsert, arr, index) {
+        const pre = arr.slice(0, index);
+        const post = arr.slice(index, arr.length);
+        return [...pre, elementToInsert, ...post];
+    }
+}
+SlickUtilsService.getHashCode = function (str) {
+    let hash = 0;
+    let chr;
+    if (str.length === 0)
+        return hash;
+    for (let i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+};
+/** @nocollapse */ SlickUtilsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickUtilsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickUtilsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickUtilsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-utils.service.js","sourceRoot":"","sources":["../../../../projects/components/src/utils/slick-utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ElementRef } from \"@angular/core\";\r\n\r\ndeclare const tinymce: any;\r\n\r\n// @dynamic\r\n@Injectable()\r\nexport class SlickUtilsService {\r\n\tstatic newGuid(): string {\r\n\t\tlet d = new Date().getTime();\r\n\t\tconst uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\r\n\t\t\tconst r = (d + Math.random() * 16) % 16 | 0;\r\n\t\t\td = Math.floor(d / 16);\r\n\t\t\treturn (c == 'x' ? r : (r & 0x3 | 0x8)).toString(16);\r\n\t\t});\r\n\t\treturn uuid;\r\n\t}\r\n\r\n\tstatic waitForElement(elementSelector: string, iterationTimeout = 50): Promise<HTMLElement> {\r\n\t\tlet infiniteLoopCheck = 10;\r\n\t\tlet iterationId: NodeJS.Timer;\r\n\t\tconst p = new Promise<HTMLElement>((resolve, reject) => {\r\n\t\t\titerationId = setInterval(() => {\r\n\t\t\t\tconst el = <HTMLElement>document.querySelector(elementSelector);\r\n\t\t\t\tif (el) {\r\n\t\t\t\t\tclearInterval(iterationId);\r\n\t\t\t\t\tresolve(el);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (--infiniteLoopCheck <= 0) {\r\n\t\t\t\t\tclearInterval(iterationId);\r\n\t\t\t\t\talert(\"Loop Check failed trying to find \" + elementSelector);\r\n\t\t\t\t\treject();\r\n\t\t\t\t}\r\n\r\n\t\t\t}, 100);\r\n\r\n\t\t});\r\n\r\n\t\treturn p;\r\n\t}\r\n\r\n\tstatic waitForElementRef(elementRef: ElementRef, iterationTimeout = 50): Promise<ElementRef> {\r\n\t\tlet infiniteLoopCheck = 10;\r\n\t\tlet iterationId: NodeJS.Timer;\r\n\t\tconst p = new Promise<ElementRef>((resolve, reject) => {\r\n\t\t\titerationId = setInterval(() => {\r\n\t\t\t\tconst el = <HTMLElement>elementRef.nativeElement;\r\n\t\t\t\tif (el && el.clientHeight && el.clientWidth) {\r\n\t\t\t\t\tclearInterval(iterationId);\r\n\t\t\t\t\tresolve(elementRef);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (--infiniteLoopCheck <= 0) {\r\n\t\t\t\t\tclearInterval(iterationId);\r\n\t\t\t\t\tconsole.error(\"Loop Check failed trying to find element\");\r\n\t\t\t\t\treject();\r\n\t\t\t\t}\r\n\t\t\t}, iterationTimeout);\r\n\r\n\t\t});\r\n\r\n\t\treturn p;\r\n\t}\r\n\r\n\tstatic getDeepObject(obj: any, objName: string): any {\r\n\t\tconst dotSplit = objName.split(\".\");\r\n\r\n\t\tlet currentObj = obj;\r\n\t\tdotSplit.forEach((o) => {\r\n\t\t\tif (currentObj === null || currentObj === undefined)\r\n\t\t\t\treturn null;\r\n\r\n\t\t\tcurrentObj = currentObj[o];\r\n\t\t});\r\n\r\n\t\treturn currentObj;\r\n\t}\r\n\r\n\tstatic setDeepObject(obj: any, objName: string, val: any) {\r\n\t\tconst dotSplit = objName.split(\".\");\r\n\r\n\t\tlet prevObj = obj;\r\n\t\tlet currentObj = obj;\r\n\t\tdotSplit.forEach((o) => {\r\n\t\t\tif (currentObj === null || currentObj === undefined)\r\n\t\t\t\treturn null;\r\n\r\n\t\t\tprevObj = currentObj;\r\n\t\t\tcurrentObj = currentObj[o];\r\n\t\t});\r\n\r\n\t\tprevObj[dotSplit[dotSplit.length - 1]] = val;\r\n\r\n\t\treturn currentObj;\r\n\t}\r\n\r\n\tstatic clone(obj: any): any {\r\n\t\tif (obj === null || obj === undefined)\r\n\t\t\treturn obj;\r\n\r\n\t\tlet returnObj = JSON.parse(JSON.stringify(obj));\r\n\t\t//returnObj = this.dateSanitize(returnObj);\r\n\r\n\t\treturn returnObj;\r\n\t}\r\n\r\n\tstatic dateSanitize(obj: any, infiniteLoopCheck: number = 0): any {\r\n\t\tinfiniteLoopCheck++;\r\n\r\n\t\tif (infiniteLoopCheck > 20) {\r\n\t\t\tconsole.error(\"infinte loop\");\r\n\t\t\treturn obj;\r\n\t\t}\r\n\r\n\t\tif (obj === null || obj === undefined)\r\n\t\t\treturn obj;\r\n\r\n\t\t// If the obj IS a date, return the processed date\r\n\t\tif (typeof obj === \"string\" && /^([0-9]{4}-(0[1-9]|10|11|12)-([012][0-9]|30|31)T([01][0-9]|[2][0123]):([0-5][0-9]):([0-5][0-9])(.[0-9]{0,})?(z|Z))$/.test(obj))\r\n\t\t\treturn new Date(obj);\r\n\r\n\t\t// If this is an atomic type (string, bool, number), just return the atomic object\r\n\t\tif (typeof obj !== \"object\")\r\n\t\t\treturn obj;\r\n\r\n\t\tlet returnObj;\r\n\t\tif (Array.isArray(obj)) {\r\n\t\t\treturnObj = [];\r\n\t\t\tobj.forEach(o => returnObj.push(this.dateSanitize(o, infiniteLoopCheck)));\r\n\t\t}\r\n\t\telse {\r\n\t\t\treturnObj = {};\r\n\r\n\t\t\tfor (const key in obj) {\r\n\t\t\t\tif (obj[key] === null)\r\n\t\t\t\t\treturnObj[key] = null;\r\n\t\t\t\telse if (Array.isArray(obj[key])) {\r\n\t\t\t\t\treturnObj[key] = [];\r\n\t\t\t\t\tobj[key].forEach(o => returnObj[key].push(this.dateSanitize(o, infiniteLoopCheck)));\r\n\t\t\t\t}\r\n\t\t\t\telse if (typeof obj[key] === \"object\")\r\n\t\t\t\t\treturnObj[key] = this.dateSanitize(obj[key], ++infiniteLoopCheck);\r\n\t\t\t\telse if (/^([0-9]{4}-(0[1-9]|10|11|12)-([012][0-9]|30|31)T([01][0-9]|[2][0123]):([0-5][0-9]):([0-5][0-9])(.[0-9]{0,})?(z|Z))$/.test(obj[key]))\r\n\t\t\t\t\treturnObj[key] = new Date(obj[key]);\r\n\t\t\t\telse\r\n\t\t\t\t\treturnObj[key] = obj[key];\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn returnObj;\r\n\t}\r\n\r\n\tstatic round(num: number, decimals: number): number {\r\n\t\treturn Number(Math.round(parseFloat(num + 'e' + decimals)) + 'e-' + decimals);\r\n\t}\r\n\r\n\tstatic checkParentClassExists(el: HTMLElement, className: string): boolean {\r\n\t\tlet currentEl: HTMLElement = el;\r\n\t\tlet hasSelector = false;\r\n\t\twhile (currentEl && currentEl !== document.body) {\r\n\t\t\tif (currentEl.classList.contains(className)) {\r\n\t\t\t\thasSelector = true;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t\tcurrentEl = currentEl.parentElement;\r\n\t\t}\r\n\r\n\t\treturn hasSelector;\r\n\t}\r\n\r\n\tstatic checkParentIdExists(el: HTMLElement, idName: string): boolean {\r\n\t\tlet currentEl: HTMLElement = el;\r\n\t\tlet hasSelector = false;\r\n\t\twhile (currentEl && currentEl !== document.body) {\r\n\t\t\tif (currentEl.getAttribute(\"id\") === idName) {\r\n\t\t\t\thasSelector = true;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t\tcurrentEl = currentEl.parentElement;\r\n\t\t}\r\n\r\n\t\treturn hasSelector;\r\n\t}\r\n\r\n\tstatic findParentByAttr(el: HTMLElement, attrName: string, attrValue: string): HTMLElement {\r\n\t\tlet currentEl: HTMLElement = el;\r\n\t\twhile (currentEl && currentEl !== document.body) {\r\n\t\t\tif (currentEl.hasAttribute(attrName) && currentEl.getAttribute(attrName) === attrValue) {\r\n\t\t\t\treturn currentEl;\r\n\t\t\t}\r\n\t\t\tcurrentEl = <HTMLElement>currentEl.parentElement;\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n\r\n\tstatic findParent(el: HTMLElement, className: string): HTMLElement {\r\n\t\tlet currentEl: HTMLElement = el;\r\n\t\twhile (currentEl && currentEl !== document.body) {\r\n\t\t\tif (currentEl.classList && currentEl.classList.contains(className)) {\r\n\t\t\t\treturn currentEl;\r\n\t\t\t}\r\n\t\t\tcurrentEl = <HTMLElement>currentEl.parentElement;\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n\r\n\r\n\tstatic getClosestSibling(el: HTMLElement, className: string): HTMLElement {\r\n\t\tlet currentEl: HTMLElement = el;\r\n\t\twhile (currentEl && currentEl !== document.body) {\r\n\t\t\tif (currentEl.classList && currentEl.classList.contains(className)) {\r\n\t\t\t\treturn currentEl;\r\n\t\t\t}\r\n\t\t\tcurrentEl = <HTMLElement>currentEl.previousSibling;\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n\r\n\tstatic getHashCode = function (str: string) {\r\n\t\tlet hash: number = 0;\r\n\t\tlet chr: number;\r\n\r\n\t\tif (str.length === 0) return hash;\r\n\t\tfor (let i = 0; i < str.length; i++) {\r\n\t\t\tchr = str.charCodeAt(i);\r\n\t\t\thash = ((hash << 5) - hash) + chr;\r\n\t\t\thash |= 0; // Convert to 32bit integer\r\n\t\t}\r\n\t\treturn Math.abs(hash);\r\n\t};\r\n\r\n\tstatic waitForTinyMCE(tinyMCEId: string): Promise<void> {\r\n\t\treturn new Promise((resolve, reject) => {\r\n\t\t\tlet waitForTinyMCE: NodeJS.Timer;\r\n\r\n\t\t\tif (tinymce.get(tinyMCEId) && tinymce.get(tinyMCEId).initialized) {\r\n\t\t\t\tresolve();\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tclearInterval(waitForTinyMCE);\r\n\t\t\t\tlet infiniteLoopCheck = 100;\r\n\t\t\t\twaitForTinyMCE = setInterval(() => {\r\n\t\t\t\t\tif ((tinymce.get(tinyMCEId) && tinymce.get(tinyMCEId).initialized) || infiniteLoopCheck === 0) {\r\n\t\t\t\t\t\tclearInterval(waitForTinyMCE);\r\n\r\n\t\t\t\t\t\tif (infiniteLoopCheck === 0) {\r\n\t\t\t\t\t\t\tconsole.error(\"Timed out waiting for tinyMCE Id: \" + tinyMCEId);\r\n\t\t\t\t\t\t\treturn reject();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\telse {\r\n\t\t\t\t\t\t\treturn resolve();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tinfiniteLoopCheck--;\r\n\t\t\t\t}, 100);\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tstatic attachElement(el: HTMLElement, attachTo: string) {\r\n\t\tif (attachTo === 'body')\r\n\t\t\tdocument.body.appendChild(el);\r\n\t\telse {\r\n\t\t\tconst parent = document.body.querySelector(attachTo);\r\n\t\t\tif (!parent) {\r\n\t\t\t\tconsole.error(\"Could not find element \" + attachTo + \" to attach to\");\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tparent.appendChild(el);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tstatic removeElement(el: HTMLElement) {\r\n\t\t// it's okay if this fails.  It was already removed\r\n\t\ttry {\r\n\t\t\t// the default destroy won't get rid of this\r\n\t\t\tdocument.body.removeChild(el);\r\n\t\t}\r\n\t\tcatch { }\r\n\t}\r\n\r\n\tstatic arrayInsert<T>(elementToInsert: T, arr: T[], index: number): T[] {\r\n\t\tconst pre = arr.slice(0, index);\r\n\t\tconst post = arr.slice(index, arr.length);\r\n\t\treturn [...pre, elementToInsert, ...post];\r\n\t}\r\n}\r\n\r\n"]}