@stemy/ngx-utils 12.1.2 → 13.0.1

package/esm2020/ngx-utils/services/static-language.service.mjs

@@ -0,0 +1,166 @@
+import { Inject, Injectable } from "@angular/core";
+import { CONFIG_SERVICE, PROMISE_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { EventsService } from "./events.service";
+import { StorageService } from "./storage.service";
+import { BaseHttpClient } from "./base-http.client";
+import * as i0 from "@angular/core";
+import * as i1 from "./events.service";
+import * as i2 from "./storage.service";
+import * as i3 from "./base-http.client";
+export class StaticLanguageService {
+    constructor(events, storage, configs, promises, client) {
+        this.events = events;
+        this.storage = storage;
+        this.configs = configs;
+        this.promises = promises;
+        this.client = client;
+        this.editLang = null;
+        this.currentLang = null;
+        this.disableTrans = false;
+        this.languageList = [];
+        this.translations = {
+            none: {}
+        };
+        this.initService();
+    }
+    get defaultLanguage() {
+        return this.configs.getQueryParameter("lang") || this.storage.get("language", this.getDefaultLanguage());
+    }
+    get dictionary() {
+        return this.translations[this.currentLanguage] || {};
+    }
+    set dictionary(value) {
+        this.translations[this.currentLanguage] = value;
+    }
+    get languages() {
+        return this.languageList;
+    }
+    get currentLanguage() {
+        return this.currentLang || this.defaultLanguage;
+    }
+    set currentLanguage(lang) {
+        this.currentLang = lang;
+        this.events.languageChanged.emit(lang);
+    }
+    get editLanguage() {
+        return this.editLang || this.currentLanguage;
+    }
+    set editLanguage(lang) {
+        this.editLang = lang || this.currentLanguage;
+    }
+    get disableTranslations() {
+        return this.disableTrans;
+    }
+    set disableTranslations(value) {
+        this.disableTrans = value;
+        this.events.languageChanged.emit(this.currentLang);
+    }
+    get httpClient() {
+        return this.client;
+    }
+    get config() {
+        return this.configs.config;
+    }
+    get universal() {
+        return this.storage.universal;
+    }
+    initService() {
+    }
+    replaceLanguages(languages) {
+        languages = Array.isArray(languages) && languages.length > 0 ? languages : this.languageList;
+        this.languageList = Array.from(new Set(languages));
+        this.languageList.forEach(lang => {
+            this.translations[lang] = this.translations[lang] || {};
+        });
+    }
+    addLanguages(languages) {
+        if (!Array.isArray(languages) || languages.length == 0)
+            return;
+        this.replaceLanguages(this.languageList.concat(languages));
+    }
+    getTranslationSync(key, params = null) {
+        const lowerKey = (key || "").toLocaleLowerCase();
+        const translation = this.dictionary[lowerKey] || lowerKey;
+        return this.interpolate(translation == lowerKey ? key : translation, params);
+    }
+    getTranslation(key, params) {
+        if (!ObjectUtils.isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        const translation = ObjectUtils.getValue(this.dictionary, key, key) || key;
+        return this.promises.resolve(this.interpolate(translation, params));
+    }
+    getTranslations(...keys) {
+        return this.promises.create(resolve => {
+            this.promises.all(keys.map(key => this.getTranslation(key))).then(translations => {
+                resolve(keys.reduce((result, key, i) => {
+                    result[key] = translations[i];
+                    return result;
+                }, {}));
+            });
+        });
+    }
+    getTranslationFromObject(translations, params, lang) {
+        lang = lang || this.currentLanguage;
+        return this.interpolate(translations ? (translations[lang] || "") : "");
+    }
+    getTranslationFromArray(translations, params, lang) {
+        lang = lang || this.currentLanguage;
+        const translation = translations ? translations.find(t => t.lang == lang) : null;
+        return this.interpolate(translation ? translation.translation : "", params);
+    }
+    interpolate(expr, params) {
+        if (typeof expr === "string") {
+            return this.interpolateString(expr, params);
+        }
+        if (typeof expr === "function") {
+            return expr(params);
+        }
+        return expr;
+    }
+    interpolateString(expr, params) {
+        if (!expr || !params)
+            return expr;
+        return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
+            const r = ObjectUtils.getValue(params, b);
+            return ObjectUtils.isDefined(r) ? r : substring;
+        });
+    }
+    getDefaultLanguage() {
+        if (!this.universal.isBrowser || typeof window.navigator === "undefined") {
+            return "de";
+        }
+        let browserLang = (window.navigator.languages ? window.navigator.languages[0] : null)
+            || window.navigator.language || window.navigator["browserLanguage"] || window.navigator["userLanguage"] || null;
+        if (!browserLang)
+            return browserLang;
+        ["-", "_"].forEach(splitter => {
+            if (browserLang.indexOf(splitter) >= 0) {
+                browserLang = browserLang.split(splitter)[0];
+            }
+        });
+        return browserLang;
+    }
+}
+StaticLanguageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StaticLanguageService, deps: [{ token: EventsService }, { token: StorageService }, { token: CONFIG_SERVICE }, { token: PROMISE_SERVICE }, { token: BaseHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+StaticLanguageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StaticLanguageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StaticLanguageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EventsService, decorators: [{
+                    type: Inject,
+                    args: [EventsService]
+                }] }, { type: i2.StorageService, decorators: [{
+                    type: Inject,
+                    args: [StorageService]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CONFIG_SERVICE]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PROMISE_SERVICE]
+                }] }, { type: i3.BaseHttpClient, decorators: [{
+                    type: Inject,
+                    args: [BaseHttpClient]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static-language.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/static-language.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from \"@angular/core\";\r\nimport {\r\n    CONFIG_SERVICE,\r\n    IConfigService,\r\n    IConfiguration,\r\n    ILanguageService,\r\n    IPromiseService,\r\n    ITranslation,\r\n    ITranslations,\r\n    PROMISE_SERVICE\r\n} from \"../common-types\";\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {EventsService} from \"./events.service\";\r\nimport {StorageService} from \"./storage.service\";\r\nimport {UniversalService} from \"./universal.service\";\r\nimport {BaseHttpClient} from \"./base-http.client\";\r\nimport {HttpClient} from \"@angular/common/http\";\r\n\r\n@Injectable()\r\nexport class StaticLanguageService implements ILanguageService {\r\n\r\n    get defaultLanguage(): string {\r\n        return this.configs.getQueryParameter(\"lang\") || this.storage.get(\"language\", this.getDefaultLanguage());\r\n    }\r\n\r\n    get dictionary(): ITranslations {\r\n        return this.translations[this.currentLanguage] || {};\r\n    }\r\n\r\n    set dictionary(value: ITranslations) {\r\n        this.translations[this.currentLanguage] = value;\r\n    }\r\n\r\n    get languages(): ReadonlyArray<string> {\r\n        return this.languageList;\r\n    }\r\n\r\n    get currentLanguage(): string {\r\n        return this.currentLang || this.defaultLanguage;\r\n    }\r\n\r\n    set currentLanguage(lang: string) {\r\n        this.currentLang = lang;\r\n        this.events.languageChanged.emit(lang);\r\n    }\r\n\r\n    get editLanguage(): string {\r\n        return this.editLang || this.currentLanguage;\r\n    }\r\n\r\n    set editLanguage(lang: string) {\r\n        this.editLang = lang || this.currentLanguage;\r\n    }\r\n\r\n    get disableTranslations(): boolean {\r\n        return this.disableTrans;\r\n    }\r\n\r\n    set disableTranslations(value: boolean) {\r\n        this.disableTrans = value;\r\n        this.events.languageChanged.emit(this.currentLang);\r\n    }\r\n\r\n    get httpClient(): HttpClient {\r\n        return this.client;\r\n    }\r\n\r\n    get config(): IConfiguration {\r\n        return this.configs.config;\r\n    }\r\n\r\n    get universal(): UniversalService {\r\n        return this.storage.universal;\r\n    }\r\n\r\n    protected editLang: string;\r\n    protected currentLang: string;\r\n    protected disableTrans: boolean;\r\n    protected languageList: string[];\r\n    protected readonly translations: ITranslations;\r\n\r\n    constructor(@Inject(EventsService) readonly events: EventsService,\r\n                @Inject(StorageService) readonly storage: StorageService,\r\n                @Inject(CONFIG_SERVICE) readonly configs: IConfigService,\r\n                @Inject(PROMISE_SERVICE) protected promises: IPromiseService,\r\n                @Inject(BaseHttpClient) protected client: BaseHttpClient) {\r\n        this.editLang = null;\r\n        this.currentLang = null;\r\n        this.disableTrans = false;\r\n        this.languageList = [];\r\n        this.translations = {\r\n            none: {}\r\n        };\r\n        this.initService();\r\n    }\r\n\r\n    protected initService(): void {\r\n\r\n    }\r\n\r\n    replaceLanguages(languages: string[]): void {\r\n        languages = Array.isArray(languages) && languages.length > 0 ? languages : this.languageList;\r\n        this.languageList = Array.from(new Set<string>(languages));\r\n        this.languageList.forEach(lang => {\r\n            this.translations[lang] = this.translations[lang] || {};\r\n        });\r\n    }\r\n\r\n    addLanguages(languages: string[]): void {\r\n        if (!Array.isArray(languages) || languages.length == 0) return;\r\n        this.replaceLanguages(this.languageList.concat(languages));\r\n    }\r\n\r\n    getTranslationSync(key: string, params: any = null): string {\r\n        const lowerKey = (key || \"\").toLocaleLowerCase();\r\n        const translation = this.dictionary[lowerKey] || lowerKey;\r\n        return this.interpolate(translation == lowerKey ? key : translation, params);\r\n    }\r\n\r\n    getTranslation(key: string, params?: any): Promise<string> {\r\n        if (!ObjectUtils.isString(key) || !key.length) {\r\n            throw new Error(`Parameter \"key\" required`);\r\n        }\r\n        const translation = ObjectUtils.getValue(this.dictionary, key, key) || key;\r\n        return this.promises.resolve(this.interpolate(translation, params));\r\n    }\r\n\r\n    getTranslations(...keys: string[]): Promise<ITranslations> {\r\n        return this.promises.create<ITranslations>(resolve => {\r\n            this.promises.all(keys.map(key => this.getTranslation(key))).then(translations => {\r\n                resolve(keys.reduce((result, key, i) => {\r\n                    result[key] = translations[i];\r\n                    return result;\r\n                }, {}));\r\n            });\r\n        });\r\n    }\r\n\r\n    getTranslationFromObject(translations: ITranslations, params?: any, lang?: string): string {\r\n        lang = lang || this.currentLanguage;\r\n        return this.interpolate(translations ? (translations[lang] || \"\") : \"\")\r\n    }\r\n\r\n    getTranslationFromArray(translations: ITranslation[], params?: any, lang?: string): string {\r\n        lang = lang || this.currentLanguage;\r\n        const translation = translations ? translations.find(t => t.lang == lang) : null;\r\n        return this.interpolate(translation ? translation.translation : \"\", params);\r\n    }\r\n\r\n    protected interpolate(expr: string | Function, params?: any): string {\r\n        if (typeof expr === \"string\") {\r\n            return this.interpolateString(expr, params);\r\n        }\r\n        if (typeof expr === \"function\") {\r\n            return expr(params);\r\n        }\r\n        return expr as string;\r\n    }\r\n\r\n    protected interpolateString(expr: string, params?: any) {\r\n        if (!expr || !params) return expr;\r\n        return expr.replace(/{{\\s?([^{}\\s]*)\\s?}}/g, (substring: string, b: string) => {\r\n            const r = ObjectUtils.getValue(params, b);\r\n            return ObjectUtils.isDefined(r) ? r : substring;\r\n        });\r\n    }\r\n\r\n    protected getDefaultLanguage(): string {\r\n        if (!this.universal.isBrowser || typeof window.navigator === \"undefined\") {\r\n            return \"de\";\r\n        }\r\n        let browserLang: string = (window.navigator.languages ? window.navigator.languages[0] : null)\r\n            || window.navigator.language || window.navigator[\"browserLanguage\"] || window.navigator[\"userLanguage\"] || null;\r\n        if (!browserLang) return browserLang;\r\n\r\n        [\"-\", \"_\"].forEach(splitter => {\r\n            if (browserLang.indexOf(splitter) >= 0) {\r\n                browserLang = browserLang.split(splitter)[0];\r\n            }\r\n        })\r\n        return browserLang;\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,49 @@
+import { Injectable } from "@angular/core";
+import { StorageMode } from "../common-types";
+import { UniversalService } from "./universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./universal.service";
+/**
+ * Use this service instead of Storage to avoid Angular Universal breaks on server environment
+ */
+export class StorageService {
+    constructor(universal) {
+        this.universal = universal;
+    }
+    get(key, defaultValue, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return defaultValue;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        const item = storage.getItem(key);
+        if (!item)
+            return defaultValue;
+        try {
+            return JSON.parse(item);
+        }
+        catch (e) {
+            return item;
+        }
+    }
+    set(key, value, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        if (typeof value == "string") {
+            storage.setItem(key, value);
+            return;
+        }
+        storage.setItem(key, JSON.stringify(value));
+    }
+    remove(key, mode = StorageMode.Local) {
+        if (!this.universal.isBrowser)
+            return;
+        const storage = mode == StorageMode.Local ? localStorage : sessionStorage;
+        storage.removeItem(key);
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StorageService, deps: [{ token: i1.UniversalService }], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.UniversalService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,32 @@
+import { Inject, Injectable } from "@angular/core";
+import { LANGUAGE_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class ConsoleToasterService {
+    constructor(language) {
+        this.language = language;
+    }
+    error(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #BD362F; color: #ffffff"));
+    }
+    info(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #2F96B4; color: #ffffff"));
+    }
+    success(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #51A351; color: #ffffff"));
+    }
+    warning(message, params, title) {
+        this.translateMessage(message, params, str => console.log(str, title, "background: #F89406; color: #ffffff"));
+    }
+    translateMessage(message, params, callback) {
+        this.language.getTranslation(message, params).then(callback);
+    }
+}
+ConsoleToasterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConsoleToasterService, deps: [{ token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+ConsoleToasterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConsoleToasterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConsoleToasterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LANGUAGE_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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;
+    }
+}
+TranslatedUrlSerializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatedUrlSerializer, deps: [{ token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslatedUrlSerializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatedUrlSerializer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TranslatedUrlSerializer, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LANGUAGE_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,78 @@
+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 {
+    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)/gi.test(info.userAgent);
+    }
+    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;
+    }
+    get browserVersion() {
+        return this.dds.browser_version;
+    }
+    get isExplorer() {
+        return this.dds.browser == "ie";
+    }
+    get isEdge() {
+        return this.dds.browser == "ms-edge";
+    }
+    get isChrome() {
+        return this.dds.browser == "chrome";
+    }
+    get isFirefox() {
+        return this.dds.browser == "firefox";
+    }
+    get isSafari() {
+        return this.dds.browser == "safari";
+    }
+    get isTablet() {
+        return this.dds.isTablet();
+    }
+    get isMobile() {
+        return this.dds.isMobile();
+    }
+    get isDesktop() {
+        return this.dds.isDesktop();
+    }
+    get isCrawler() {
+        return this.crawler;
+    }
+}
+UniversalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UniversalService, deps: [{ token: PLATFORM_ID }, { token: i1.DeviceDetectorService }], target: i0.ɵɵFactoryTarget.Injectable });
+UniversalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UniversalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UniversalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.DeviceDetectorService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,40 @@
+export class AjaxRequestHandler {
+    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;
+    }
+}
+AjaxRequestHandler.isOverridden = false;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+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;
+    }
+}
+//# 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"]}