@stemy/ngx-utils 12.1.2 → 13.0.1

package/esm2020/ngx-utils/pipes/translate.pipe.mjs

@@ -0,0 +1,86 @@
+import { ChangeDetectorRef, Inject, Injectable, Pipe } from "@angular/core";
+import { LANGUAGE_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class TranslatePipe {
+    constructor(cdr, language) {
+        this.cdr = cdr;
+        this.language = language;
+    }
+    get currentLang() {
+        return this.language.currentLanguage;
+    }
+    transform(query, ...args) {
+        if (!query)
+            return "";
+        let dirty = false;
+        const lang = this.currentLang;
+        if (this.lang !== lang) {
+            this.lang = lang;
+            dirty = true;
+        }
+        const disabled = this.language.disableTranslations;
+        if (this.disabled !== disabled) {
+            this.disabled = disabled;
+            dirty = true;
+        }
+        if (!ObjectUtils.equals(this.query, query)) {
+            this.query = query;
+            dirty = true;
+        }
+        if (!ObjectUtils.equals(this.args, args)) {
+            this.args = args;
+            this.params = null;
+            if (ObjectUtils.isDefined(args[0]) && args.length) {
+                if (typeof args[0] === "string" && args[0].length) {
+                    const validArgs = args[0]
+                        .replace(/(\')?([a-zA-Z0-9_]+)(\')?(\s)?:/g, `"$2":`)
+                        .replace(/:(\s)?(\')(.*?)(\')/g, `:"$3"`);
+                    try {
+                        this.params = JSON.parse(validArgs);
+                    }
+                    catch (e) {
+                        throw new SyntaxError(`Wrong parameter in TranslatePipe. Expected a valid Object, received: ${args[0]}`);
+                    }
+                }
+                else if (typeof args[0] === "object" && !Array.isArray(args[0])) {
+                    this.params = args[0];
+                }
+            }
+            dirty = true;
+        }
+        if (dirty) {
+            if (typeof query === "object") {
+                this.lastValue = Array.isArray(query) ? this.language.getTranslationFromArray(query, this.params, lang) : this.language.getTranslationFromObject(query, this.params, lang);
+                return this.lastValue;
+            }
+            if (this.disabled) {
+                this.lastValue = query;
+                return this.lastValue;
+            }
+            this.language.getTranslation(query, this.params).then(value => {
+                this.lastValue = value;
+                if (!this.cdr["destroyed"]) {
+                    this.cdr.detectChanges();
+                }
+            });
+        }
+        return this.lastValue;
+    }
+}
+TranslatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatePipe, deps: [{ token: i0.ChangeDetectorRef }, { token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Pipe });
+TranslatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatePipe, name: "translate", pure: false });
+TranslatePipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatePipe });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Injectable
+        }, {
+            type: Pipe,
+            args: [{
+                    name: "translate",
+                    pure: false
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LANGUAGE_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbmd4LXV0aWxzL3BpcGVzL3RyYW5zbGF0ZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxpQkFBaUIsRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBZ0IsTUFBTSxlQUFlLENBQUM7QUFDekYsT0FBTyxFQUFtQixnQkFBZ0IsRUFBbUIsTUFBTSxpQkFBaUIsQ0FBQztBQUNyRixPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sdUJBQXVCLENBQUM7O0FBT2xELE1BQU0sT0FBTyxhQUFhO0lBYXRCLFlBQXFCLEdBQXNCLEVBQXFDLFFBQTBCO1FBQXJGLFFBQUcsR0FBSCxHQUFHLENBQW1CO1FBQXFDLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBRTFHLENBQUM7SUFORCxJQUFJLFdBQVc7UUFDWCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFBO0lBQ3hDLENBQUM7SUFNRCxTQUFTLENBQUMsS0FBdUIsRUFBRSxHQUFHLElBQVc7UUFDN0MsSUFBSSxDQUFDLEtBQUs7WUFBRSxPQUFPLEVBQUUsQ0FBQztRQUN0QixJQUFJLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbEIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQztRQUM5QixJQUFJLElBQUksQ0FBQyxJQUFJLEtBQUssSUFBSSxFQUFFO1lBQ3BCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1lBQ2pCLEtBQUssR0FBRyxJQUFJLENBQUM7U0FDaEI7UUFDRCxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLG1CQUFtQixDQUFDO1FBQ25ELElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxRQUFRLEVBQUU7WUFDNUIsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7WUFDekIsS0FBSyxHQUFHLElBQUksQ0FBQztTQUNoQjtRQUNELElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLEVBQUU7WUFDeEMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7WUFDbkIsS0FBSyxHQUFHLElBQUksQ0FBQztTQUNoQjtRQUNELElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEVBQUU7WUFDdEMsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7WUFDakIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUM7WUFDbkIsSUFBSSxXQUFXLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUU7Z0JBQy9DLElBQUksT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssUUFBUSxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUU7b0JBQy9DLE1BQU0sU0FBUyxHQUFXLElBQUksQ0FBQyxDQUFDLENBQUM7eUJBQzVCLE9BQU8sQ0FBQyxrQ0FBa0MsRUFBRSxPQUFPLENBQUM7eUJBQ3BELE9BQU8sQ0FBQyxzQkFBc0IsRUFBRSxPQUFPLENBQUMsQ0FBQztvQkFDOUMsSUFBSTt3QkFDQSxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7cUJBQ3ZDO29CQUFDLE9BQU8sQ0FBQyxFQUFFO3dCQUNSLE1BQU0sSUFBSSxXQUFXLENBQUMsd0VBQXdFLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7cUJBQzVHO2lCQUNKO3FCQUFNLElBQUksT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRTtvQkFDL0QsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQ3pCO2FBQ0o7WUFDRCxLQUFLLEdBQUcsSUFBSSxDQUFDO1NBQ2hCO1FBQ0QsSUFBSSxLQUFLLEVBQUU7WUFDUCxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsRUFBRTtnQkFDM0IsSUFBSSxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLHVCQUF1QixDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLHdCQUF3QixDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO2dCQUMzSyxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7YUFDekI7WUFDRCxJQUFJLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ2YsSUFBSSxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUM7Z0JBQ3ZCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQzthQUN6QjtZQUNELElBQUksQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUMxRCxJQUFJLENBQUMsU0FBUyxHQUFHLEtBQUssQ0FBQztnQkFDdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLEVBQUU7b0JBQ3hCLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUM7aUJBQzVCO1lBQ0wsQ0FBQyxDQUFDLENBQUM7U0FDTjtRQUNELE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUMxQixDQUFDOzswR0F0RVEsYUFBYSxtREFhK0IsZ0JBQWdCO3dHQWI1RCxhQUFhOzhHQUFiLGFBQWE7MkZBQWIsYUFBYTtrQkFMekIsVUFBVTs7a0JBQ1YsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsV0FBVztvQkFDakIsSUFBSSxFQUFFLEtBQUs7aUJBQ2Q7OzBCQWNpRCxNQUFNOzJCQUFDLGdCQUFnQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q2hhbmdlRGV0ZWN0b3JSZWYsIEluamVjdCwgSW5qZWN0YWJsZSwgUGlwZSwgUGlwZVRyYW5zZm9ybX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtJTGFuZ3VhZ2VTZXJ2aWNlLCBMQU5HVUFHRV9TRVJWSUNFLCBUcmFuc2xhdGlvblF1ZXJ5fSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcbmltcG9ydCB7T2JqZWN0VXRpbHN9IGZyb20gXCIuLi91dGlscy9vYmplY3QudXRpbHNcIjtcclxuXHJcbkBJbmplY3RhYmxlKClcclxuQFBpcGUoe1xyXG4gICAgbmFtZTogXCJ0cmFuc2xhdGVcIixcclxuICAgIHB1cmU6IGZhbHNlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUcmFuc2xhdGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblxyXG4gICAgcHJpdmF0ZSBsYW5nOiBzdHJpbmc7XHJcbiAgICBwcml2YXRlIGRpc2FibGVkOiBib29sZWFuO1xyXG4gICAgcHJpdmF0ZSBxdWVyeTogVHJhbnNsYXRpb25RdWVyeTtcclxuICAgIHByaXZhdGUgYXJnczogYW55W107XHJcbiAgICBwcml2YXRlIHBhcmFtczogYW55O1xyXG4gICAgcHJpdmF0ZSBsYXN0VmFsdWU6IHN0cmluZztcclxuXHJcbiAgICBnZXQgY3VycmVudExhbmcoKTogc3RyaW5nIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5sYW5ndWFnZS5jdXJyZW50TGFuZ3VhZ2VcclxuICAgIH1cclxuXHJcbiAgICBjb25zdHJ1Y3RvcihyZWFkb25seSBjZHI6IENoYW5nZURldGVjdG9yUmVmLCBASW5qZWN0KExBTkdVQUdFX1NFUlZJQ0UpIHJlYWRvbmx5IGxhbmd1YWdlOiBJTGFuZ3VhZ2VTZXJ2aWNlKSB7XHJcblxyXG4gICAgfVxyXG5cclxuICAgIHRyYW5zZm9ybShxdWVyeTogVHJhbnNsYXRpb25RdWVyeSwgLi4uYXJnczogYW55W10pOiBzdHJpbmcge1xyXG4gICAgICAgIGlmICghcXVlcnkpIHJldHVybiBcIlwiO1xyXG4gICAgICAgIGxldCBkaXJ0eSA9IGZhbHNlO1xyXG4gICAgICAgIGNvbnN0IGxhbmcgPSB0aGlzLmN1cnJlbnRMYW5nO1xyXG4gICAgICAgIGlmICh0aGlzLmxhbmcgIT09IGxhbmcpIHtcclxuICAgICAgICAgICAgdGhpcy5sYW5nID0gbGFuZztcclxuICAgICAgICAgICAgZGlydHkgPSB0cnVlO1xyXG4gICAgICAgIH1cclxuICAgICAgICBjb25zdCBkaXNhYmxlZCA9IHRoaXMubGFuZ3VhZ2UuZGlzYWJsZVRyYW5zbGF0aW9ucztcclxuICAgICAgICBpZiAodGhpcy5kaXNhYmxlZCAhPT0gZGlzYWJsZWQpIHtcclxuICAgICAgICAgICAgdGhpcy5kaXNhYmxlZCA9IGRpc2FibGVkO1xyXG4gICAgICAgICAgICBkaXJ0eSA9IHRydWU7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIGlmICghT2JqZWN0VXRpbHMuZXF1YWxzKHRoaXMucXVlcnksIHF1ZXJ5KSkge1xyXG4gICAgICAgICAgICB0aGlzLnF1ZXJ5ID0gcXVlcnk7XHJcbiAgICAgICAgICAgIGRpcnR5ID0gdHJ1ZTtcclxuICAgICAgICB9XHJcbiAgICAgICAgaWYgKCFPYmplY3RVdGlscy5lcXVhbHModGhpcy5hcmdzLCBhcmdzKSkge1xyXG4gICAgICAgICAgICB0aGlzLmFyZ3MgPSBhcmdzO1xyXG4gICAgICAgICAgICB0aGlzLnBhcmFtcyA9IG51bGw7XHJcbiAgICAgICAgICAgIGlmIChPYmplY3RVdGlscy5pc0RlZmluZWQoYXJnc1swXSkgJiYgYXJncy5sZW5ndGgpIHtcclxuICAgICAgICAgICAgICAgIGlmICh0eXBlb2YgYXJnc1swXSA9PT0gXCJzdHJpbmdcIiAmJiBhcmdzWzBdLmxlbmd0aCkge1xyXG4gICAgICAgICAgICAgICAgICAgIGNvbnN0IHZhbGlkQXJnczogc3RyaW5nID0gYXJnc1swXVxyXG4gICAgICAgICAgICAgICAgICAgICAgICAucmVwbGFjZSgvKFxcJyk/KFthLXpBLVowLTlfXSspKFxcJyk/KFxccyk/Oi9nLCBgXCIkMlwiOmApXHJcbiAgICAgICAgICAgICAgICAgICAgICAgIC5yZXBsYWNlKC86KFxccyk/KFxcJykoLio/KShcXCcpL2csIGA6XCIkM1wiYCk7XHJcbiAgICAgICAgICAgICAgICAgICAgdHJ5IHtcclxuICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5wYXJhbXMgPSBKU09OLnBhcnNlKHZhbGlkQXJncyk7XHJcbiAgICAgICAgICAgICAgICAgICAgfSBjYXRjaCAoZSkge1xyXG4gICAgICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgU3ludGF4RXJyb3IoYFdyb25nIHBhcmFtZXRlciBpbiBUcmFuc2xhdGVQaXBlLiBFeHBlY3RlZCBhIHZhbGlkIE9iamVjdCwgcmVjZWl2ZWQ6ICR7YXJnc1swXX1gKTtcclxuICAgICAgICAgICAgICAgICAgICB9XHJcbiAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKHR5cGVvZiBhcmdzWzBdID09PSBcIm9iamVjdFwiICYmICFBcnJheS5pc0FycmF5KGFyZ3NbMF0pKSB7XHJcbiAgICAgICAgICAgICAgICAgICAgdGhpcy5wYXJhbXMgPSBhcmdzWzBdO1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIGRpcnR5ID0gdHJ1ZTtcclxuICAgICAgICB9XHJcbiAgICAgICAgaWYgKGRpcnR5KSB7XHJcbiAgICAgICAgICAgIGlmICh0eXBlb2YgcXVlcnkgPT09IFwib2JqZWN0XCIpIHtcclxuICAgICAgICAgICAgICAgIHRoaXMubGFzdFZhbHVlID0gQXJyYXkuaXNBcnJheShxdWVyeSkgPyB0aGlzLmxhbmd1YWdlLmdldFRyYW5zbGF0aW9uRnJvbUFycmF5KHF1ZXJ5LCB0aGlzLnBhcmFtcywgbGFuZykgOiB0aGlzLmxhbmd1YWdlLmdldFRyYW5zbGF0aW9uRnJvbU9iamVjdChxdWVyeSwgdGhpcy5wYXJhbXMsIGxhbmcpO1xyXG4gICAgICAgICAgICAgICAgcmV0dXJuIHRoaXMubGFzdFZhbHVlO1xyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIGlmICh0aGlzLmRpc2FibGVkKSB7XHJcbiAgICAgICAgICAgICAgICB0aGlzLmxhc3RWYWx1ZSA9IHF1ZXJ5O1xyXG4gICAgICAgICAgICAgICAgcmV0dXJuIHRoaXMubGFzdFZhbHVlO1xyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIHRoaXMubGFuZ3VhZ2UuZ2V0VHJhbnNsYXRpb24ocXVlcnksIHRoaXMucGFyYW1zKS50aGVuKHZhbHVlID0+IHtcclxuICAgICAgICAgICAgICAgIHRoaXMubGFzdFZhbHVlID0gdmFsdWU7XHJcbiAgICAgICAgICAgICAgICBpZiAoIXRoaXMuY2RyW1wiZGVzdHJveWVkXCJdKSB7XHJcbiAgICAgICAgICAgICAgICAgICAgdGhpcy5jZHIuZGV0ZWN0Q2hhbmdlcygpO1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICB9KTtcclxuICAgICAgICB9XHJcbiAgICAgICAgcmV0dXJuIHRoaXMubGFzdFZhbHVlO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/ngx-utils/pipes/values.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+const emptyValues = [];
+export class ValuesPipe {
+    transform(value) {
+        if (!value)
+            return emptyValues;
+        return ObjectUtils.isArray(value)
+            ? value
+            : Object.keys(value).map(key => value[key]);
+    }
+}
+ValuesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ValuesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ValuesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ValuesPipe, name: "values" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ValuesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "values"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdWVzLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbmd4LXV0aWxzL3BpcGVzL3ZhbHVlcy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxJQUFJLEVBQWdCLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQzs7QUFFbEQsTUFBTSxXQUFXLEdBQVUsRUFBRSxDQUFDO0FBSzlCLE1BQU0sT0FBTyxVQUFVO0lBRW5CLFNBQVMsQ0FBQyxLQUFVO1FBQ2hCLElBQUksQ0FBQyxLQUFLO1lBQUUsT0FBTyxXQUFXLENBQUM7UUFDL0IsT0FBTyxXQUFXLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztZQUM3QixDQUFDLENBQUMsS0FBSztZQUNQLENBQUMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ3BELENBQUM7O3VHQVBRLFVBQVU7cUdBQVYsVUFBVTsyRkFBVixVQUFVO2tCQUh0QixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxRQUFRO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGlwZSwgUGlwZVRyYW5zZm9ybX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtPYmplY3RVdGlsc30gZnJvbSBcIi4uL3V0aWxzL29iamVjdC51dGlsc1wiO1xyXG5cclxuY29uc3QgZW1wdHlWYWx1ZXM6IGFueVtdID0gW107XHJcblxyXG5AUGlwZSh7XHJcbiAgICBuYW1lOiBcInZhbHVlc1wiXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBWYWx1ZXNQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblxyXG4gICAgdHJhbnNmb3JtKHZhbHVlOiBhbnkpOiBhbnlbXSB7XHJcbiAgICAgICAgaWYgKCF2YWx1ZSkgcmV0dXJuIGVtcHR5VmFsdWVzO1xyXG4gICAgICAgIHJldHVybiBPYmplY3RVdGlscy5pc0FycmF5KHZhbHVlKVxyXG4gICAgICAgICAgICA/IHZhbHVlXHJcbiAgICAgICAgICAgIDogT2JqZWN0LmtleXModmFsdWUpLm1hcChrZXkgPT4gdmFsdWVba2V5XSk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/ngx-utils/plugins/resize-event.plugin.mjs

@@ -0,0 +1,59 @@
+import { ɵDomEventsPlugin as EventManagerPlugin } from "@angular/platform-browser";
+import { Inject, Injectable } from "@angular/core";
+import { DOCUMENT } from "@angular/common";
+import { addListener, removeListener } from "resize-detector";
+import { UniversalService } from "../services/universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/universal.service";
+function emptyRemove() {
+}
+function isWindow(el) {
+    return typeof window !== "undefined" && el === window;
+}
+export class ResizeEventPlugin extends EventManagerPlugin {
+    constructor(doc, universal) {
+        super(doc);
+        this.universal = universal;
+    }
+    supports(eventName) {
+        return eventName === ResizeEventPlugin.EVENT_NAME;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        return zone.runOutsideAngular(() => {
+            if (this.universal.isServer)
+                return emptyRemove;
+            const cb = el => {
+                zone.run(() => handler(el));
+            };
+            if (isWindow(element)) {
+                element.addEventListener(eventName, cb);
+            }
+            else {
+                addListener(element, cb);
+            }
+            return () => {
+                try {
+                    if (isWindow(element)) {
+                        element.removeEventListener(eventName, cb);
+                    }
+                    else {
+                        removeListener(element, cb);
+                    }
+                }
+                catch (e) {
+                }
+            };
+        });
+    }
+}
+ResizeEventPlugin.EVENT_NAME = "resize";
+ResizeEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ResizeEventPlugin, deps: [{ token: DOCUMENT }, { token: i1.UniversalService }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ResizeEventPlugin });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ResizeEventPlugin, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.UniversalService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/plugins/scroll-event.plugin.mjs

@@ -0,0 +1,39 @@
+import { ɵDomEventsPlugin as EventManagerPlugin } from "@angular/platform-browser";
+import { Inject, Injectable } from "@angular/core";
+import { DOCUMENT } from "@angular/common";
+import { UniversalService } from "../services/universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/universal.service";
+export function emptyRemove() {
+}
+export class ScrollEventPlugin extends EventManagerPlugin {
+    constructor(doc, universal) {
+        super(doc);
+        this.universal = universal;
+    }
+    supports(eventName) {
+        return eventName === ScrollEventPlugin.EVENT_NAME;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        return zone.runOutsideAngular(() => {
+            if (this.universal.isServer)
+                return emptyRemove;
+            const callback = (e) => {
+                zone.run(() => handler(e));
+            };
+            element.addEventListener(eventName, callback);
+            return () => element.removeEventListener(eventName, callback);
+        });
+    }
+}
+ScrollEventPlugin.EVENT_NAME = "scroll";
+ScrollEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ScrollEventPlugin, deps: [{ token: DOCUMENT }, { token: i1.UniversalService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ScrollEventPlugin });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ScrollEventPlugin, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.UniversalService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/acl.service.mjs

@@ -0,0 +1,81 @@
+import { Inject, Injectable, Injector } from "@angular/core";
+import { StateService } from "./state.service";
+import { AUTH_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { AuthGuard } from "../utils/auth.guard";
+import * as i0 from "@angular/core";
+import * as i1 from "./state.service";
+const emptyGuards = [];
+export class AclService {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+        this.components = [];
+        this.auth.userChanged.subscribe(() => {
+            this.components.forEach(t => t.dirty = true);
+            const info = this.getStateInfo();
+            const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
+            check.then(result => {
+                if (result) {
+                    if (!info || !info.dirty)
+                        return;
+                    info.dirty = false;
+                    const component = info.component;
+                    if (info.first) {
+                        if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                            component.onUserInitialized();
+                        }
+                        info.first = false;
+                        return;
+                    }
+                    if (ObjectUtils.isFunction(component.onUserChanged)) {
+                        component.onUserChanged();
+                    }
+                    return;
+                }
+                info.guard.getReturnState(info.route).then(returnState => {
+                    if (!returnState)
+                        return;
+                    this.state.navigate(returnState);
+                });
+            });
+        });
+        this.state.subscribe(() => {
+            const info = this.getStateInfo();
+            if (!info?.component)
+                return;
+            const component = info.component;
+            if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                component.onUserInitialized();
+            }
+        });
+    }
+    getStateInfo() {
+        const route = this.state.route;
+        if (!route)
+            return null;
+        let info = this.components.find(t => t.route == this.state.route);
+        if (!info) {
+            const guardType = (route.canActivate || emptyGuards)[0];
+            info = {
+                route: this.state.route,
+                guard: guardType ? this.injector.get(guardType) : null,
+                dirty: true,
+                first: true
+            };
+            this.components.push(info);
+        }
+        info.component = this.state.component;
+        return info;
+    }
+}
+AclService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, deps: [{ token: i0.Injector }, { token: i1.StateService }, { token: AUTH_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+AclService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.StateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTH_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/api.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from "@angular/core";
+import { BaseHttpService } from "./base-http.service";
+import * as i0 from "@angular/core";
+export class ApiService extends BaseHttpService {
+    get name() {
+        return "api";
+    }
+    url(url) {
+        return this.expressRequestUrl(`/api/${url}`);
+    }
+    get(url, options, body) {
+        return this.getPromise(url, options, body);
+    }
+    delete(url, options, body) {
+        return this.deletePromise(url, options, body);
+    }
+    post(url, body, options) {
+        return this.postPromise(url, body, options);
+    }
+    put(url, body, options) {
+        return this.putPromise(url, body, options);
+    }
+    patch(url, body, options) {
+        return this.patchPromise(url, body, options);
+    }
+    upload(url, body, listener, options) {
+        return this.uploadPromise(url, body, listener, options);
+    }
+    list(url, params) {
+        return this.listPromise(url, params);
+    }
+}
+ApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+ApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/auth.service.mjs

@@ -0,0 +1,14 @@
+import { EventEmitter } from "@angular/core";
+export class StaticAuthService {
+    constructor() {
+        this.isAuthenticated = true;
+        this.userChanged = new EventEmitter();
+    }
+    checkAuthenticated() {
+        return Promise.resolve(this.isAuthenticated);
+    }
+    getReturnState(route) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9zZXJ2aWNlcy9hdXRoLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUczQyxNQUFNLE9BQU8saUJBQWlCO0lBQTlCO1FBRUksb0JBQWUsR0FBWSxJQUFJLENBQUM7UUFDaEMsZ0JBQVcsR0FBc0IsSUFBSSxZQUFZLEVBQU8sQ0FBQztJQVM3RCxDQUFDO0lBUEcsa0JBQWtCO1FBQ2QsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUNqRCxDQUFDO0lBRUQsY0FBYyxDQUFDLEtBQWE7UUFDeEIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFdmVudEVtaXR0ZXJ9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7SVJvdXRlLCBJQXV0aFNlcnZpY2V9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBTdGF0aWNBdXRoU2VydmljZSBpbXBsZW1lbnRzIElBdXRoU2VydmljZSB7XHJcblxyXG4gICAgaXNBdXRoZW50aWNhdGVkOiBib29sZWFuID0gdHJ1ZTtcclxuICAgIHVzZXJDaGFuZ2VkOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXI8YW55PigpO1xyXG5cclxuICAgIGNoZWNrQXV0aGVudGljYXRlZCgpOiBQcm9taXNlPGJvb2xlYW4+IHtcclxuICAgICAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHRoaXMuaXNBdXRoZW50aWNhdGVkKTtcclxuICAgIH1cclxuXHJcbiAgICBnZXRSZXR1cm5TdGF0ZShyb3V0ZTogSVJvdXRlKTogc3RyaW5nW10ge1xyXG4gICAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/ngx-utils/services/base-http.client.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from "@angular/core";
+import { HttpClient, HttpHandler, HttpHeaders, HttpParams, HttpUrlEncodingCodec } from "@angular/common/http";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class BaseHttpClient extends HttpClient {
+    constructor(handler) {
+        super(handler);
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.extraRequestParams = {
+            language: "en"
+        };
+    }
+    makeHeaders(headers, withCredentials = true) {
+        headers = Object.assign({}, this.requestHeaders, headers);
+        const authHeader = headers["Authorization"] || "";
+        if (!withCredentials && !authHeader.startsWith("Bearer")) {
+            delete headers["Authorization"];
+        }
+        return new HttpHeaders(headers);
+    }
+    makeParams(params) {
+        params = Object.assign({}, this.extraRequestParams, this.requestParams, params);
+        return new HttpParams({
+            encoder: new HttpUrlEncodingCodec(),
+            fromObject: Object.keys(params || {}).reduce((result, key) => {
+                const value = params[key];
+                result[key] = ObjectUtils.isObject(value) ? JSON.stringify(value) : (ObjectUtils.isNullOrUndefined(value) ? "" : value.toString());
+                return result;
+            }, {})
+        });
+    }
+    setExtraRequestParam(name, value) {
+        if (typeof value == "undefined") {
+            delete this.extraRequestParams[name];
+            return;
+        }
+        this.extraRequestParams[name] = value;
+    }
+}
+BaseHttpClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BaseHttpClient, deps: [{ token: i1.HttpHandler }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseHttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BaseHttpClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BaseHttpClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,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