@stemy/ngx-utils 13.6.17 → 17.0.0

package/esm2022/ngx-utils/services/translated-url.serializer.mjs

@@ -0,0 +1,73 @@
+import { Inject, Injectable } from "@angular/core";
+import { DefaultUrlSerializer, UrlSegment, UrlSegmentGroup, UrlTree } from "@angular/router";
+import { LANGUAGE_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class TranslatedUrlSerializer extends DefaultUrlSerializer {
+    constructor(language) {
+        super();
+        this.language = language;
+        this.cache = {};
+    }
+    serialize(tree) {
+        const copy = new UrlTree();
+        const dictionary = this.getDictionary(true);
+        copy.root = this.modifyTreeRecursive(tree.root, segment => {
+            segment.path = dictionary[segment.path] || segment.path;
+        });
+        copy.queryParams = tree.queryParams;
+        return super.serialize(copy);
+    }
+    parse(url) {
+        const tree = super.parse(url);
+        const dictionary = this.getDictionary(false);
+        tree.root = this.modifyTreeRecursive(tree.root, segment => {
+            segment.path = dictionary[segment.path] || segment.path;
+        });
+        return tree;
+    }
+    getDictionary(serialize) {
+        const method = serialize ? `serialize` : `parse`;
+        const key = `${this.language.currentLanguage}-${method}`;
+        if (!this.cache[key]) {
+            const dict = this.language.dictionary;
+            this.cache[key] = Object.keys(dict).reduce((res, key) => {
+                if (!key.startsWith("route."))
+                    return res;
+                const value = dict[key];
+                key = key.replace("route.", "");
+                res[serialize ? key : value] = serialize ? value : key;
+                return res;
+            }, {});
+        }
+        return this.cache[key];
+    }
+    modifyTreeRecursive(segmentGroup, cb) {
+        if (!segmentGroup)
+            return null;
+        const childrenArr = [];
+        const children = Object.keys(segmentGroup.children || {}).reduce((res, key) => {
+            const child = this.modifyTreeRecursive(segmentGroup.children[key], cb);
+            childrenArr.push(child);
+            res[key] = child;
+            return res;
+        }, {});
+        const newGroup = new UrlSegmentGroup(segmentGroup.segments.map(s => {
+            s = new UrlSegment(s.path, Object.assign({}, s.parameters));
+            cb(s);
+            return s;
+        }), children);
+        childrenArr.forEach(c => {
+            c.parent = newGroup;
+        });
+        return newGroup;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TranslatedUrlSerializer, deps: [{ token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TranslatedUrlSerializer }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TranslatedUrlSerializer, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LANGUAGE_SERVICE]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngx-utils/services/universal.service.mjs

@@ -0,0 +1,81 @@
+import { Inject, Injectable, PLATFORM_ID } from "@angular/core";
+import { isPlatformBrowser, isPlatformServer } from "@angular/common";
+import { DeviceDetectorService } from "ngx-device-detector";
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-device-detector";
+/**
+ * Use this service to determine which is the current environment
+ */
+export class UniversalService {
+    get isBrowser() {
+        return isPlatformBrowser(this.platformId);
+    }
+    get isServer() {
+        return isPlatformServer(this.platformId);
+    }
+    get deviceInfo() {
+        return this.isServer
+            ? {
+                userAgent: "angular-universal",
+                os: "unknown",
+                browser: "node",
+                device: "node",
+                os_version: "unknown",
+                browser_version: "unknown",
+                deviceType: "unknown",
+                orientation: "landscape"
+            }
+            : this.dds.getDeviceInfo();
+    }
+    get browserName() {
+        return (this.dds.browser || "").toLowerCase();
+    }
+    get browserVersion() {
+        return this.dds.browser_version;
+    }
+    get isExplorer() {
+        return this.checkBrowser("ie");
+    }
+    get isEdge() {
+        return this.checkBrowser("edge");
+    }
+    get isChrome() {
+        return this.checkBrowser("chrome");
+    }
+    get isFirefox() {
+        return this.checkBrowser("firefox");
+    }
+    get isSafari() {
+        return this.checkBrowser("safari");
+    }
+    get isTablet() {
+        return this.dds.isTablet();
+    }
+    get isMobile() {
+        return this.dds.isMobile();
+    }
+    get isDesktop() {
+        return this.dds.isDesktop();
+    }
+    get isCrawler() {
+        return this.crawler;
+    }
+    constructor(platformId, dds) {
+        this.platformId = platformId;
+        this.dds = dds;
+        const info = this.dds.getDeviceInfo();
+        this.crawler = /(bot|google|baidu|bing|msn|duckduckbot|teoma|slurp|yandex|lighthouse|angular-universal|PTST|PostmanRuntime)/gi.test(info.userAgent);
+    }
+    checkBrowser(name) {
+        return this.browserName.includes(name) || false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UniversalService, deps: [{ token: PLATFORM_ID }, { token: i1.DeviceDetectorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UniversalService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UniversalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.DeviceDetectorService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/ngx-utils/services/wasm.service.mjs

@@ -1,46 +1,46 @@
-import { Inject, Injectable } from "@angular/core";
-import { WASI_IMPLEMENTATION } from "../common-types";
-import { WasmWorkerProxy } from "../utils/wasm-worker-proxy";
-import { UniversalService } from "./universal.service";
-import { LocalHttpService } from "./local-http.service";
-import * as i0 from "@angular/core";
-import * as i1 from "./universal.service";
-import * as i2 from "./local-http.service";
-/**
- * Use this service to load WebAssembly modules
- */
-export class WasmService {
-    constructor(universal, http, wasi) {
-        this.universal = universal;
-        this.http = http;
-        this.wasi = wasi.constructor;
-    }
-    async getModule(name) {
-        if (!this.universal.isBrowser || !name)
-            return null;
-        this.modules = this.modules || {};
-        this.modules[name] = this.modules[name] || this.http.get(`wasm/${name}.wasm`, {
-            responseType: "arraybuffer"
-        }).then(async (bytes) => {
-            const wasi = new this.wasi();
-            return await wasi.instantiate(bytes);
-        });
-        return this.modules[name];
-    }
-    getWorkerModule(name) {
-        if (!this.universal.isBrowser || !name)
-            return null;
-        this.workerModules = this.workerModules || {};
-        this.workerModules[name] = new WasmWorkerProxy(this.http.url(`wasm/${name}.wasm`), this.wasi);
-        return this.workerModules[name];
-    }
-}
-WasmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: WasmService, deps: [{ token: i1.UniversalService }, { token: i2.LocalHttpService }, { token: WASI_IMPLEMENTATION }], target: i0.ɵɵFactoryTarget.Injectable });
-WasmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: WasmService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: WasmService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.UniversalService }, { type: i2.LocalHttpService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [WASI_IMPLEMENTATION]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Inject, Injectable } from "@angular/core";
+import { WASI_IMPLEMENTATION } from "../common-types";
+import { WasmWorkerProxy } from "../utils/wasm-worker-proxy";
+import { UniversalService } from "./universal.service";
+import { LocalHttpService } from "./local-http.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./universal.service";
+import * as i2 from "./local-http.service";
+/**
+ * Use this service to load WebAssembly modules
+ */
+export class WasmService {
+    constructor(universal, http, wasi) {
+        this.universal = universal;
+        this.http = http;
+        this.wasi = wasi.constructor;
+    }
+    async getModule(name) {
+        if (!this.universal.isBrowser || !name)
+            return null;
+        this.modules = this.modules || {};
+        this.modules[name] = this.modules[name] || this.http.get(`wasm/${name}.wasm`, {
+            responseType: "arraybuffer"
+        }).then(async (bytes) => {
+            const wasi = new this.wasi();
+            return await wasi.instantiate(bytes);
+        });
+        return this.modules[name];
+    }
+    getWorkerModule(name) {
+        if (!this.universal.isBrowser || !name)
+            return null;
+        this.workerModules = this.workerModules || {};
+        this.workerModules[name] = new WasmWorkerProxy(this.http.url(`wasm/${name}.wasm`), this.wasi);
+        return this.workerModules[name];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WasmService, deps: [{ token: i1.UniversalService }, { token: i2.LocalHttpService }, { token: WASI_IMPLEMENTATION }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WasmService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WasmService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.UniversalService }, { type: i2.LocalHttpService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WASI_IMPLEMENTATION]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngx-utils/utils/ajax-request-handler.mjs

@@ -0,0 +1,40 @@
+export class AjaxRequestHandler {
+    static { this.isOverridden = false; }
+    constructor(pattern, callback) {
+        this.pattern = pattern;
+        this.callback = callback;
+        this.listener = (event) => {
+            const details = event.detail;
+            if (this.pattern.test(details.url))
+                this.callback(details, this.params);
+        };
+        this.params = {};
+        if (typeof XMLHttpRequest !== "undefined" && !AjaxRequestHandler.isOverridden) {
+            AjaxRequestHandler.isOverridden = true;
+            const originalOpen = XMLHttpRequest.prototype.open;
+            XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
+                originalOpen.apply(this, arguments);
+                window.dispatchEvent(new CustomEvent("ajaxRequest", {
+                    detail: {
+                        request: this,
+                        method: method,
+                        url: url
+                    }
+                }));
+            };
+        }
+    }
+    listen() {
+        if (typeof window === "undefined")
+            return this;
+        window.addEventListener("ajaxRequest", this.listener);
+        return this;
+    }
+    forget() {
+        if (typeof window === "undefined")
+            return;
+        window.removeEventListener("ajaxRequest", this.listener);
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngx-utils/utils/array.utils.mjs

@@ -0,0 +1,107 @@
+import { ObjectUtils } from "./object.utils";
+export class ArrayUtils {
+    static has(arr, ...items) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isArray(items))
+            return false;
+        for (let i = 0; i < items.length; i++) {
+            if (arr.indexOf(items[i]) >= 0)
+                return true;
+        }
+        return false;
+    }
+    static match(arr, str) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isString(str))
+            return false;
+        for (let i = 0; i < arr.length; i++) {
+            if (arr[i] instanceof RegExp) {
+                const regex = arr[i];
+                if (regex.test(str))
+                    return true;
+            }
+        }
+        return false;
+    }
+    static any(arr, cb) {
+        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isFunction(cb))
+            return false;
+        for (let i = 0; i < arr.length; i++) {
+            if (cb(arr[i]))
+                return true;
+        }
+        return false;
+    }
+    static move(arr, oldIndex, newIndex) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        const length = arr.length;
+        while (oldIndex < 0) {
+            oldIndex += length;
+        }
+        while (newIndex < 0) {
+            newIndex += length;
+        }
+        if (newIndex >= length) {
+            let k = newIndex - length + 1;
+            while (k--) {
+                arr.push(undefined);
+            }
+        }
+        arr.splice(newIndex, 0, arr.splice(oldIndex, 1)[0]);
+        return arr;
+    }
+    static reversed(arr) {
+        const result = [];
+        if (!ObjectUtils.isArray(arr))
+            return result;
+        for (let i = arr.length - 1; i >= 0; i--) {
+            result.push(arr[i]);
+        }
+        return result;
+    }
+    static min(arr, cb) {
+        if (!ObjectUtils.isArray(arr))
+            return null;
+        let min = Number.MAX_SAFE_INTEGER;
+        let result = null;
+        for (let i = 0; i < arr.length; i++) {
+            const current = cb(arr[i], i);
+            if (current < min || result === null) {
+                min = current;
+                result = arr[i];
+            }
+        }
+        return result;
+    }
+    static max(arr, cb) {
+        if (!ObjectUtils.isArray(arr))
+            return null;
+        let max = Number.MIN_SAFE_INTEGER;
+        let result = null;
+        for (let i = 0; i < arr.length; i++) {
+            const current = cb(arr[i], i);
+            if (current > max || result === null) {
+                max = current;
+                result = arr[i];
+            }
+        }
+        return result;
+    }
+    static chunk(arr, size) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        size = Math.max(1, size);
+        const result = [];
+        for (let i = 0; i < arr.length; i += size) {
+            result.push(arr.slice(i, i + size));
+        }
+        return result;
+    }
+    static unique(arr) {
+        if (!ObjectUtils.isArray(arr))
+            return [];
+        return arr.filter((value, index, self) => {
+            return self.indexOf(value) === index;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.utils.js","sourceRoot":"","sources":["../../../../src/ngx-utils/utils/array.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {ObjectUtils} from \"./object.utils\";\r\n\r\nexport class ArrayUtils {\r\n\r\n    static has(arr: any[], ...items: any[]): boolean {\r\n        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isArray(items)) return false;\r\n        for (let i = 0; i < items.length; i++) {\r\n            if (arr.indexOf(items[i]) >= 0) return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    static match(arr: any[], str: string): boolean {\r\n        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isString(str)) return false;\r\n        for (let i = 0; i < arr.length; i++) {\r\n            if (arr[i] instanceof RegExp) {\r\n                const regex = <RegExp>arr[i];\r\n                if (regex.test(str)) return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    static any<T>(arr: T[], cb: (item: T) => boolean): boolean {\r\n        if (!ObjectUtils.isArray(arr) || !ObjectUtils.isFunction(cb)) return false;\r\n        for (let i = 0; i < arr.length; i++) {\r\n            if (cb(arr[i])) return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    static move<T>(arr: T[], oldIndex: number, newIndex: number): T[] {\r\n        if (!ObjectUtils.isArray(arr)) return [];\r\n        const length = arr.length;\r\n        while (oldIndex < 0) {\r\n            oldIndex += length;\r\n        }\r\n        while (newIndex < 0) {\r\n            newIndex += length;\r\n        }\r\n        if (newIndex >= length) {\r\n            let k = newIndex - length + 1;\r\n            while (k--) {\r\n                arr.push(undefined);\r\n            }\r\n        }\r\n        arr.splice(newIndex, 0, arr.splice(oldIndex, 1)[0]);\r\n        return arr;\r\n    }\r\n\r\n    static reversed(arr: any[]): any[] {\r\n        const result = [];\r\n        if (!ObjectUtils.isArray(arr)) return result;\r\n        for (let i = arr.length - 1; i >= 0; i--) {\r\n            result.push(arr[i]);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    static min<T>(arr: T[], cb: (item: T, index?: number) => number): T {\r\n        if (!ObjectUtils.isArray(arr)) return null;\r\n        let min = Number.MAX_SAFE_INTEGER;\r\n        let result = null;\r\n        for (let i = 0; i < arr.length; i++) {\r\n            const current = cb(arr[i], i);\r\n            if (current < min || result === null) {\r\n                min = current;\r\n                result = arr[i];\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n\r\n    static max<T>(arr: T[], cb: (item: T, index?: number) => number): T {\r\n        if (!ObjectUtils.isArray(arr)) return null;\r\n        let max = Number.MIN_SAFE_INTEGER;\r\n        let result = null;\r\n        for (let i = 0; i < arr.length; i++) {\r\n            const current = cb(arr[i], i);\r\n            if (current > max || result === null) {\r\n                max = current;\r\n                result = arr[i];\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n\r\n    static chunk<T>(arr: T[], size: number): Array<T[]> {\r\n        if (!ObjectUtils.isArray(arr)) return [];\r\n        size = Math.max(1, size);\r\n        const result = []\r\n        for (let i = 0; i < arr.length; i += size) {\r\n            result.push(arr.slice(i, i + size))\r\n        }\r\n        return result\r\n    }\r\n\r\n    static unique<T>(arr: T[]): T[] {\r\n        if (!ObjectUtils.isArray(arr)) return [];\r\n        return arr.filter((value, index, self) => {\r\n            return self.indexOf(value) === index;\r\n        });\r\n    }\r\n}\r\n"]}