@acorex/core 6.5.28 → 6.5.30

package/esm2020/lib/platform/platform.service.mjs

@@ -0,0 +1,150 @@
+import { Injectable } from "@angular/core";
+import { fromEvent, Subject } from "rxjs";
+import { debounceTime, distinctUntilChanged } from "rxjs/operators";
+import * as i0 from "@angular/core";
+const isChrome = (win) => testUserAgent(win, /Chrome/i);
+const isFirefox = (win) => testUserAgent(win, /Firefox/i);
+const isEdge = (win) => testUserAgent(win, /Edge/i);
+const isSafari = (win) => testUserAgent(win, /Safari/i);
+const isOpera = (win) => testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);
+const isMSIE = (win) => testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);
+const isMobileWeb = (win) => isMobile(win) && !isHybrid(win);
+const isIpad = (win) => {
+    // iOS 12 and below
+    if (testUserAgent(win, /iPad/i)) {
+        return true;
+    }
+    // iOS 13+
+    if (testUserAgent(win, /Macintosh/i) && isMobile(win)) {
+        return true;
+    }
+    return false;
+};
+const isIphone = (win) => testUserAgent(win, /iPhone/i);
+const isIOS = (win) => testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
+const isAndroid = (win) => testUserAgent(win, /android|sink/i);
+const isAndroidTablet = (win) => {
+    return isAndroid(win) && !testUserAgent(win, /mobile/i);
+};
+const isPhablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (smallest > 390 && smallest < 520) &&
+        (largest > 620 && largest < 800);
+};
+const isTablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (isIpad(win) ||
+        isAndroidTablet(win) ||
+        ((smallest > 460 && smallest < 820) &&
+            (largest > 780 && largest < 1400)));
+};
+const isMobile = (win) => matchMedia(win, '(any-pointer:coarse)');
+const isTouch = (win) => matchMedia(win, '(any-pointer:coarse)');
+const isDesktop = (win) => !isMobile(win);
+const isHybrid = (win) => isCordova(win) || isCapacitorNative(win);
+const isCordova = (win) => !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);
+const isCapacitorNative = (win) => {
+    const capacitor = win['Capacitor'];
+    return !!(capacitor && capacitor.isNative);
+};
+const isElectron = (win) => testUserAgent(win, /electron/i);
+const isPWA = (win) => !!(win.matchMedia('(display-mode: standalone)').matches || win.navigator.standalone);
+export const testUserAgent = (win, expr) => expr.test(win.navigator.userAgent);
+const matchMedia = (win, query) => win.matchMedia(query).matches;
+const isSMScreen = (win) => matchMedia(win, '(max-width: 640px)');
+const isMDScreen = (win) => matchMedia(win, '(max-width: 768px)');
+const isLGScreen = (win) => matchMedia(win, '(max-width: 1024px)');
+const isXLScreen = (win) => matchMedia(win, '(max-width: 1280px)');
+const is2XLScreen = (win) => matchMedia(win, '(max-width: 1536px)');
+const PLATFORMS_MAP = {
+    'Android': isAndroid,
+    'iOS': isIOS,
+    'Desktop': isDesktop,
+    'Mobile': isMobile,
+    'Touch': isTouch,
+    'Chrome': isChrome,
+    'Firefox': isFirefox,
+    'Safari': isSafari,
+    'Edge': isEdge,
+    'Opera': isOpera,
+    'Hybrid': isHybrid,
+    'PWA': isPWA,
+    'Electron': isElectron,
+    SM: isSMScreen,
+    MD: isMDScreen,
+    LG: isLGScreen,
+    XL: isXLScreen,
+    "2XL": is2XLScreen,
+};
+export class AXPlatformEvent {
+}
+export class AXPlatform {
+    constructor() {
+        this.resize = new Subject();
+        this.click = new Subject();
+        this.scroll = new Subject();
+        fromEvent(window, 'resize')
+            .pipe(debounceTime(100))
+            .pipe(distinctUntilChanged())
+            .subscribe((e) => {
+            this.resize.next({
+                nativeEvent: e,
+                source: this
+            });
+            //
+            this._setFullHeightRatio();
+        });
+        document.addEventListener('click', (e) => {
+            this.click.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        document.addEventListener('scroll', (e) => {
+            this.scroll.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        // init functions
+        this._setFullHeightRatio();
+    }
+    isRtl() {
+        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
+    }
+    isLandscape() {
+        return window.innerHeight < window.innerWidth;
+    }
+    isPortrate() {
+        return !this.isLandscape();
+    }
+    is(name) {
+        return PLATFORMS_MAP[name](window) || false;
+    }
+    switchDarkMode() {
+        const _html = document.getElementsByTagName("html")[0];
+        _html.classList.add('ax-dark');
+    }
+    switchLightMode() {
+        const _html = document.getElementsByTagName("html")[0];
+        _html.classList.remove('ax-dark');
+    }
+    _setFullHeightRatio() {
+        document.querySelector(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');
+    }
+}
+AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform.service.js","sourceRoot":"","sources":["../../../../../../projects/acorex/core/src/lib/platform/platform.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { from, fromEvent, Subject } from \"rxjs\";\nimport { debounceTime, distinctUntilChanged } from \"rxjs/operators\";\n\n\nexport type AXPlatforms = 'Android' | 'Desktop' | 'iOS' | 'Mobile' | '';\nexport type AXBrowsers = 'Chrome' | 'Safari' | 'Edge' | 'Firefox' | 'Opera' | 'MSIE';\nexport type AXTechnologies = 'PWA' | 'Hybrid' | 'Electron';\nexport type AXScreenSizes = 'SM' | 'MD' | 'LG' | 'XL' | '2XL';\n\n\n\nconst isChrome = (win: Window): boolean =>\n    testUserAgent(win, /Chrome/i);\n\nconst isFirefox = (win: Window): boolean =>\n    testUserAgent(win, /Firefox/i);\n\nconst isEdge = (win: Window): boolean =>\n    testUserAgent(win, /Edge/i);\n\nconst isSafari = (win: Window): boolean =>\n    testUserAgent(win, /Safari/i);\n\nconst isOpera = (win: Window): boolean =>\n    testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);\n\nconst isMSIE = (win: Window): boolean =>\n    testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);\n\n\nconst isMobileWeb = (win: Window): boolean =>\n    isMobile(win) && !isHybrid(win);\n\nconst isIpad = (win: Window) => {\n    // iOS 12 and below\n    if (testUserAgent(win, /iPad/i)) {\n        return true;\n    }\n\n    // iOS 13+\n    if (testUserAgent(win, /Macintosh/i) && isMobile(win)) {\n        return true;\n    }\n\n    return false;\n};\n\nconst isIphone = (win: Window) =>\n    testUserAgent(win, /iPhone/i);\n\nconst isIOS = (win: Window) =>\n    testUserAgent(win, /iPhone|iPod/i) || isIpad(win);\n\nconst isAndroid = (win: Window) =>\n    testUserAgent(win, /android|sink/i);\n\nconst isAndroidTablet = (win: Window) => {\n    return isAndroid(win) && !testUserAgent(win, /mobile/i);\n};\n\nconst isPhablet = (win: Window) => {\n    const width = win.innerWidth;\n    const height = win.innerHeight;\n    const smallest = Math.min(width, height);\n    const largest = Math.max(width, height);\n\n    return (smallest > 390 && smallest < 520) &&\n        (largest > 620 && largest < 800);\n};\n\nconst isTablet = (win: Window) => {\n    const width = win.innerWidth;\n    const height = win.innerHeight;\n    const smallest = Math.min(width, height);\n    const largest = Math.max(width, height);\n\n    return (\n        isIpad(win) ||\n        isAndroidTablet(win) ||\n        (\n            (smallest > 460 && smallest < 820) &&\n            (largest > 780 && largest < 1400)\n        )\n    );\n};\n\nconst isMobile = (win: Window) =>\n    matchMedia(win, '(any-pointer:coarse)');\n\nconst isTouch = (win: Window) => matchMedia(win, '(any-pointer:coarse)');\n\nconst isDesktop = (win: Window) =>\n    !isMobile(win);\n\nconst isHybrid = (win: Window) =>\n    isCordova(win) || isCapacitorNative(win);\n\nconst isCordova = (win: any): boolean =>\n    !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);\n\nconst isCapacitorNative = (win: any): boolean => {\n    const capacitor = win['Capacitor'];\n    return !!(capacitor && capacitor.isNative);\n};\n\nconst isElectron = (win: Window): boolean =>\n    testUserAgent(win, /electron/i);\n\nconst isPWA = (win: Window): boolean =>\n    !!(win.matchMedia('(display-mode: standalone)').matches || (win.navigator as any).standalone);\n\nexport const testUserAgent = (win: Window, expr: RegExp) =>\n    expr.test(win.navigator.userAgent);\n\nconst matchMedia = (win: Window, query: string): boolean =>\n    win.matchMedia(query).matches;\n\nconst isSMScreen = (win: Window) => matchMedia(win, '(max-width: 640px)');\nconst isMDScreen = (win: Window) => matchMedia(win, '(max-width: 768px)');\nconst isLGScreen = (win: Window) => matchMedia(win, '(max-width: 1024px)');\nconst isXLScreen = (win: Window) => matchMedia(win, '(max-width: 1280px)');\nconst is2XLScreen = (win: Window) => matchMedia(win, '(max-width: 1536px)');\n\nconst PLATFORMS_MAP = {\n    'Android': isAndroid,\n    'iOS': isIOS,\n    'Desktop': isDesktop,\n    'Mobile': isMobile,\n    'Touch': isTouch,\n    'Chrome': isChrome,\n    'Firefox': isFirefox,\n    'Safari': isSafari,\n    'Edge': isEdge,\n    'Opera': isOpera,\n    'Hybrid': isHybrid,\n    'PWA': isPWA,\n    'Electron': isElectron,\n    SM: isSMScreen,\n    MD: isMDScreen,\n    LG: isLGScreen,\n    XL: isXLScreen,\n    \"2XL\": is2XLScreen,\n};\n\n\nexport class AXPlatformEvent {\n    nativeEvent: UIEvent | Event;\n    source: AXPlatform\n}\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class AXPlatform {\n    resize: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>();\n    click: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>()\n    scroll: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>()\n\n    isRtl(): boolean {\n        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';\n    }\n\n\n    isLandscape(): boolean {\n        return window.innerHeight < window.innerWidth;\n    }\n\n    isPortrate(): boolean {\n        return !this.isLandscape()\n    }\n\n    is(name: AXPlatforms | AXBrowsers | AXTechnologies | AXScreenSizes): boolean {\n        return PLATFORMS_MAP[name](window) || false;\n    }\n\n    switchDarkMode() {\n        const _html = document.getElementsByTagName(\"html\")[0];\n        _html.classList.add('ax-dark')\n\n    }\n\n    switchLightMode() {\n        const _html = document.getElementsByTagName(\"html\")[0];\n        _html.classList.remove('ax-dark')\n    }\n\n    private _setFullHeightRatio() {\n        document.querySelector<HTMLElement>(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');\n    }\n\n    constructor() {\n\n        fromEvent<UIEvent>(window, 'resize')\n            .pipe(debounceTime(100))\n            .pipe(distinctUntilChanged())\n            .subscribe((e) => {\n                this.resize.next({\n                    nativeEvent: e,\n                    source: this\n                });\n                //\n                this._setFullHeightRatio();\n            });\n\n\n        document.addEventListener('click', (e) => {\n            this.click.next({\n                nativeEvent: e,\n                source: this\n            });\n        }, true)\n\n        document.addEventListener('scroll', (e) => {\n            this.scroll.next({\n                nativeEvent: e,\n                source: this\n            });\n        }, true);\n        // init functions\n        this._setFullHeightRatio();\n    }\n}"]}

package/esm2020/lib/services/config.mjs

@@ -0,0 +1,29 @@
+import { Subject } from 'rxjs';
+import { getPropByPath, setPropByPath } from '../utils/object/object-util';
+// @dynamic
+export class AXConfig {
+    static get onChange() {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+    static set(arg1, arg2) {
+        if (arg1 && typeof arg1 == 'string') {
+            setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (arg1 && typeof arg1 == 'object') {
+            Object.assign(AXConfig.dataModel, arg1);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (!arg1 && !arg2) {
+            return AXConfig.dataChangeSubject.asObservable();
+        }
+    }
+    static get(path) {
+        return getPropByPath(AXConfig.dataModel, path);
+    }
+}
+AXConfig.dataModel = {};
+AXConfig.dataChangeSubject = new Subject();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/event.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXEventService {
+    constructor() {
+        this.list = [];
+    }
+    broadcast(key, options) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events.forEach(c => {
+                c(options);
+            });
+        }
+    }
+    on(key, callback) {
+        let d = this.list.find(c => c.key === key);
+        if (!d) {
+            d = { key, events: [] };
+            this.list.push(d);
+        }
+        d.events.push(callback);
+    }
+    destroy(key, callback) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events = [];
+        }
+    }
+}
+AXEventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/navigator.service.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXNavigator {
+}
+AXNavigator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXNavigator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdG9yLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY29yZXgvY29yZS9zcmMvbGliL3NlcnZpY2VzL25hdmlnYXRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNDLE1BQU0sT0FBZ0IsV0FBVzs7eUdBQVgsV0FBVzs2R0FBWCxXQUFXOzRGQUFYLFdBQVc7a0JBRGhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWE5hdmlnYXRvclBhcmFtIH0gZnJvbSAnLi4vY2xhc3Nlcy9uYXZpZ2F0b3IuY2xhc3MnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQVhOYXZpZ2F0b3Ige1xuICAgIGFic3RyYWN0IG5hdmlnYXRlKHBhcmFtczogQVhOYXZpZ2F0b3JQYXJhbSk7XG4gICAgYWJzdHJhY3QgcG9wdXAocGFyYW1zOiBBWE5hdmlnYXRvclBhcmFtKTtcbn0iXX0=

package/esm2020/lib/services/storage.service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXStorageService {
+    get(key) {
+        return localStorage.getItem(key);
+    }
+    set(key, value) {
+        localStorage.setItem(key, value);
+    }
+}
+AXStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNvcmV4L2NvcmUvc3JjL2xpYi9zZXJ2aWNlcy9zdG9yYWdlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLGdCQUFnQjtJQUMxQixHQUFHLENBQUMsR0FBVztRQUNaLE9BQU8sWUFBWSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQVEsQ0FBQztJQUMzQyxDQUFDO0lBQ0QsR0FBRyxDQUFDLEdBQVcsRUFBRSxLQUFVO1FBQ3hCLFlBQVksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEtBQWUsQ0FBQyxDQUFDO0lBQzlDLENBQUM7OzhHQU5TLGdCQUFnQjtrSEFBaEIsZ0JBQWdCOzRGQUFoQixnQkFBZ0I7a0JBRDVCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBBWFN0b3JhZ2VTZXJ2aWNlIHtcbiAgIGdldChrZXk6IHN0cmluZyk6IGFueSB7XG4gICAgICByZXR1cm4gbG9jYWxTdG9yYWdlLmdldEl0ZW0oa2V5KSBhcyBhbnk7XG4gICB9XG4gICBzZXQoa2V5OiBzdHJpbmcsIHZhbHVlOiBhbnkpOiB2b2lkIHtcbiAgICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKGtleSwgdmFsdWUgYXMgc3RyaW5nKTtcbiAgIH1cbn1cbiJdfQ==

package/esm2020/lib/translator/translator.mjs

@@ -0,0 +1,26 @@
+import { Subject } from 'rxjs';
+import { getPropByPath } from '../utils/object/object-util';
+import merge from 'lodash-es/merge';
+// @dynamic
+export class AXTranslator {
+    static get onChange() {
+        return AXTranslator.dataChangeSubject.asObservable();
+    }
+    static load(lang, value) {
+        if (typeof value === 'object') {
+            if (!AXTranslator[`__data__${lang}`]) {
+                AXTranslator[`__data__${lang}`] = {};
+            }
+            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
+        }
+    }
+    static use(lang) {
+        AXTranslator.lang = lang;
+    }
+    static get(key, lang) {
+        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+    }
+}
+AXTranslator.lang = 'en';
+AXTranslator.dataChangeSubject = new Subject();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb3JlL3NyYy9saWIvdHJhbnNsYXRvci90cmFuc2xhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQWMsTUFBTSxNQUFNLENBQUM7QUFDM0MsT0FBTyxFQUFFLGFBQWEsRUFBQyxNQUFNLDZCQUE2QixDQUFDO0FBQzNELE9BQU8sS0FBSyxNQUFNLGlCQUFpQixDQUFDO0FBRXBDLFdBQVc7QUFDWCxNQUFNLE9BQU8sWUFBWTtJQUtyQixNQUFNLEtBQUssUUFBUTtRQUNmLE9BQU8sWUFBWSxDQUFDLGlCQUFpQixDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3pELENBQUM7SUFFTSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQVksRUFBRSxLQUFVO1FBQ3ZDLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO1lBQzNCLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQyxFQUFFO2dCQUNsQyxZQUFZLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQyxHQUFHLEVBQUUsQ0FBQzthQUN4QztZQUNELFlBQVksQ0FBQyxXQUFXLElBQUksRUFBRSxDQUFDLEdBQUcsS0FBSyxDQUFDLFlBQVksQ0FBQyxXQUFXLElBQUksRUFBRSxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDbkY7SUFDTCxDQUFDO0lBRU0sTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFZO1FBQzFCLFlBQVksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQzdCLENBQUM7SUFFTSxNQUFNLENBQUMsR0FBRyxDQUFDLEdBQVcsRUFBRSxJQUFhO1FBQ3hDLE9BQU8sYUFBYSxDQUFDLFlBQVksQ0FBQyxXQUFXLElBQUksSUFBSSxZQUFZLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUM7SUFDM0YsQ0FBQzs7QUF2QmMsaUJBQUksR0FBVyxJQUFJLENBQUM7QUFDcEIsOEJBQWlCLEdBQUcsSUFBSSxPQUFPLEVBQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFN1YmplY3QsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGdldFByb3BCeVBhdGh9IGZyb20gJy4uL3V0aWxzL29iamVjdC9vYmplY3QtdXRpbCc7XG5pbXBvcnQgbWVyZ2UgZnJvbSAnbG9kYXNoLWVzL21lcmdlJztcblxuLy8gQGR5bmFtaWNcbmV4cG9ydCBjbGFzcyBBWFRyYW5zbGF0b3Ige1xuICAgIHByaXZhdGUgc3RhdGljIGxhbmc6IHN0cmluZyA9ICdlbic7XG4gICAgcHJpdmF0ZSBzdGF0aWMgZGF0YUNoYW5nZVN1YmplY3QgPSBuZXcgU3ViamVjdDxhbnk+KCk7XG5cblxuICAgIHN0YXRpYyBnZXQgb25DaGFuZ2UoKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICAgICAgcmV0dXJuIEFYVHJhbnNsYXRvci5kYXRhQ2hhbmdlU3ViamVjdC5hc09ic2VydmFibGUoKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgc3RhdGljIGxvYWQobGFuZzogc3RyaW5nLCB2YWx1ZTogYW55KSB7XG4gICAgICAgIGlmICh0eXBlb2YgdmFsdWUgPT09ICdvYmplY3QnKSB7XG4gICAgICAgICAgICBpZiAoIUFYVHJhbnNsYXRvcltgX19kYXRhX18ke2xhbmd9YF0pIHtcbiAgICAgICAgICAgICAgICBBWFRyYW5zbGF0b3JbYF9fZGF0YV9fJHtsYW5nfWBdID0ge307XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBBWFRyYW5zbGF0b3JbYF9fZGF0YV9fJHtsYW5nfWBdID0gbWVyZ2UoQVhUcmFuc2xhdG9yW2BfX2RhdGFfXyR7bGFuZ31gXSwgdmFsdWUpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHVibGljIHN0YXRpYyB1c2UobGFuZzogc3RyaW5nKSB7XG4gICAgICAgIEFYVHJhbnNsYXRvci5sYW5nID0gbGFuZztcbiAgICB9XG5cbiAgICBwdWJsaWMgc3RhdGljIGdldChrZXk6IHN0cmluZywgbGFuZz86IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBnZXRQcm9wQnlQYXRoKEFYVHJhbnNsYXRvcltgX19kYXRhX18ke2xhbmcgfHwgQVhUcmFuc2xhdG9yLmxhbmd9YF0sIGtleSkgfHwga2V5O1xuICAgIH1cbn0iXX0=

package/esm2020/lib/translator/translator.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { AXTranslatorPipe } from './translator.pipe';
+import * as en from '../locale/en.json';
+import * as fa from '../locale/fa.json';
+import { AXTranslator } from './translator';
+import * as i0 from "@angular/core";
+export class AXTranslatorModule {
+    constructor() {
+        AXTranslator.load('en', en);
+        AXTranslator.load('fa', fa);
+    }
+}
+AXTranslatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXTranslatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
+AXTranslatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXTranslatorPipe],
+                    declarations: [AXTranslatorPipe],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRvci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY29yZXgvY29yZS9zcmMvbGliL3RyYW5zbGF0b3IvdHJhbnNsYXRvci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hDLE9BQU8sS0FBSyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGNBQWMsQ0FBQzs7QUFTNUMsTUFBTSxPQUFPLGtCQUFrQjtJQUMzQjtRQUNJLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQzVCLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7O2dIQUpRLGtCQUFrQjtpSEFBbEIsa0JBQWtCLGlCQUhaLGdCQUFnQixhQURyQixnQkFBZ0I7aUhBSWpCLGtCQUFrQixhQUZoQixFQUFFLFlBSEosRUFBRTs0RkFLRixrQkFBa0I7a0JBTjlCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLEVBQUU7b0JBQ1gsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7b0JBQzNCLFlBQVksRUFBRSxDQUFDLGdCQUFnQixDQUFDO29CQUNoQyxTQUFTLEVBQUUsRUFBRTtpQkFDaEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQVhUcmFuc2xhdG9yUGlwZSB9IGZyb20gJy4vdHJhbnNsYXRvci5waXBlJztcbmltcG9ydCAqIGFzIGVuIGZyb20gJy4uL2xvY2FsZS9lbi5qc29uJztcbmltcG9ydCAqIGFzIGZhIGZyb20gJy4uL2xvY2FsZS9mYS5qc29uJztcbmltcG9ydCB7IEFYVHJhbnNsYXRvciB9IGZyb20gJy4vdHJhbnNsYXRvcic7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbXSxcbiAgICBleHBvcnRzOiBbQVhUcmFuc2xhdG9yUGlwZV0sXG4gICAgZGVjbGFyYXRpb25zOiBbQVhUcmFuc2xhdG9yUGlwZV0sXG4gICAgcHJvdmlkZXJzOiBbXSxcbn0pXG5leHBvcnQgY2xhc3MgQVhUcmFuc2xhdG9yTW9kdWxlIHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgQVhUcmFuc2xhdG9yLmxvYWQoJ2VuJywgZW4pO1xuICAgICAgICBBWFRyYW5zbGF0b3IubG9hZCgnZmEnLCBmYSk7XG4gICAgfVxufVxuIl19

package/esm2020/lib/translator/translator.pipe.mjs

@@ -0,0 +1,24 @@
+import { Pipe } from '@angular/core';
+import { AXTranslator } from './translator';
+import * as i0 from "@angular/core";
+export class AXTranslatorPipe {
+    constructor() { }
+    // transform(value: string, lang?: string): Promise<string> {
+    //     return new Promise<string>((resolve, reject) => {
+    //         if (!value) {
+    //             resolve(value);
+    //         }
+    //         resolve(this.translate.get(value, lang));
+    //     });
+    // }
+    transform(value, lang) {
+        return AXTranslator.get(value, lang);
+    }
+}
+AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'trans', pure: true }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRvci5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNvcmV4L2NvcmUvc3JjL2xpYi90cmFuc2xhdG9yL3RyYW5zbGF0b3IucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDOztBQUc1QyxNQUFNLE9BQU8sZ0JBQWdCO0lBRXpCLGdCQUFnQixDQUFDO0lBRWpCLDZEQUE2RDtJQUM3RCx3REFBd0Q7SUFDeEQsd0JBQXdCO0lBQ3hCLDhCQUE4QjtJQUM5QixZQUFZO0lBQ1osb0RBQW9EO0lBQ3BELFVBQVU7SUFFVixJQUFJO0lBRUosU0FBUyxDQUFDLEtBQWEsRUFBRSxJQUFhO1FBQ2xDLE9BQU8sWUFBWSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDekMsQ0FBQzs7OEdBaEJRLGdCQUFnQjs0R0FBaEIsZ0JBQWdCOzRGQUFoQixnQkFBZ0I7a0JBRDVCLElBQUk7bUJBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWFRyYW5zbGF0b3IgfSBmcm9tICcuL3RyYW5zbGF0b3InO1xuXG5AUGlwZSh7IG5hbWU6ICd0cmFucycsIHB1cmU6IHRydWUgfSlcbmV4cG9ydCBjbGFzcyBBWFRyYW5zbGF0b3JQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgICBjb25zdHJ1Y3RvcigpIHsgfVxuXG4gICAgLy8gdHJhbnNmb3JtKHZhbHVlOiBzdHJpbmcsIGxhbmc/OiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIC8vICAgICByZXR1cm4gbmV3IFByb21pc2U8c3RyaW5nPigocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgLy8gICAgICAgICBpZiAoIXZhbHVlKSB7XG4gICAgLy8gICAgICAgICAgICAgcmVzb2x2ZSh2YWx1ZSk7XG4gICAgLy8gICAgICAgICB9XG4gICAgLy8gICAgICAgICByZXNvbHZlKHRoaXMudHJhbnNsYXRlLmdldCh2YWx1ZSwgbGFuZykpO1xuICAgIC8vICAgICB9KTtcblxuICAgIC8vIH1cblxuICAgIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nLCBsYW5nPzogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIEFYVHJhbnNsYXRvci5nZXQodmFsdWUsIGxhbmcpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/translator/translator.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { AXTranslator } from './translator';
+import * as i0 from "@angular/core";
+export class AXTranslatorService {
+    load(lang, value) {
+        AXTranslator.load(lang, value);
+    }
+    use(lang) {
+        AXTranslator.use(lang);
+    }
+    get(key, lang) {
+        return AXTranslator.get(lang, lang);
+    }
+}
+AXTranslatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXTranslatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, providedIn: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNvcmV4L2NvcmUvc3JjL2xpYi90cmFuc2xhdG9yL3RyYW5zbGF0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7O0FBRzVDLE1BQU0sT0FBTyxtQkFBbUI7SUFFckIsSUFBSSxDQUFDLElBQVksRUFBRSxLQUFVO1FBQ2hDLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFTSxHQUFHLENBQUMsSUFBWTtRQUNuQixZQUFZLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFFTSxHQUFHLENBQUMsR0FBVyxFQUFFLElBQWE7UUFDakMsT0FBTyxZQUFZLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUN4QyxDQUFDOztpSEFaUSxtQkFBbUI7cUhBQW5CLG1CQUFtQixjQUROLFVBQVU7NEZBQ3ZCLG1CQUFtQjtrQkFEL0IsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWFRyYW5zbGF0b3IgfSBmcm9tICcuL3RyYW5zbGF0b3InO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdwbGF0Zm9ybScgfSlcbmV4cG9ydCBjbGFzcyBBWFRyYW5zbGF0b3JTZXJ2aWNlIHtcblxuICAgIHB1YmxpYyBsb2FkKGxhbmc6IHN0cmluZywgdmFsdWU6IGFueSkge1xuICAgICAgICBBWFRyYW5zbGF0b3IubG9hZChsYW5nLCB2YWx1ZSk7XG4gICAgfVxuXG4gICAgcHVibGljIHVzZShsYW5nOiBzdHJpbmcpIHtcbiAgICAgICAgQVhUcmFuc2xhdG9yLnVzZShsYW5nKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgZ2V0KGtleTogc3RyaW5nLCBsYW5nPzogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIEFYVHJhbnNsYXRvci5nZXQobGFuZywgbGFuZyk7XG4gICAgfVxufVxuXG4iXX0=

package/esm2020/lib/utils/array/array-util.mjs

@@ -0,0 +1,133 @@
+import { AXFetchProp } from '../object/object-util';
+// @dynamic
+export class AXArrayUtil {
+    static pickRandom(array) {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+    static insert(array, index, ...rest) {
+        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));
+        return array;
+    }
+    static range(min, max) {
+        return new Array(max - min).fill(1).map((d, i) => i);
+    }
+    static filter(array, filters) {
+        if (filters == null || filters.length === 0) {
+            return array;
+        }
+        const lamda = (item) => {
+            let result = true;
+            for (const key in filters) {
+                if (filters.hasOwnProperty(key)) {
+                    const f = filters[key];
+                    if (f !== 'AND') {
+                        const vals = [];
+                        const mt = f.field.match(/\[\:(.*?)\]/);
+                        if (mt && mt.length > 1) {
+                            const p1 = f.field.replace(mt[0], '');
+                            const p2 = mt[1];
+                            const prop = AXFetchProp(item, p1);
+                            if (prop instanceof Array && prop.length) {
+                                vals.push(...prop.map(m => (AXFetchProp(m, p2))));
+                            }
+                            else {
+                                result = false;
+                            }
+                        }
+                        else {
+                            vals.push(AXFetchProp(item, f.field));
+                        }
+                        for (const j in vals) {
+                            if (vals.hasOwnProperty(j)) {
+                                let v1 = vals[j];
+                                const v2 = f.value;
+                                if (f.dataType === 'string') {
+                                    v1 = v1.toString();
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = (v1 && v2) && v1.toLowerCase() === v2.toLowerCase();
+                                            break;
+                                        case 'not-equal':
+                                            result = !((v1 && v2) && v1.toLowerCase() === v2.toLowerCase());
+                                            break;
+                                        case 'contains':
+                                            result = ((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'not-contains':
+                                            result = !((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'start-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().startsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'end-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().endsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else if (f.dataType === 'date') {
+                                }
+                                else if (f.dataType === 'number') {
+                                    v1 = Number(v1);
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = v1 === v2;
+                                            break;
+                                        case 'not-equal':
+                                            result = v1 !== v2;
+                                            break;
+                                        case 'contains':
+                                            result = v2 && v2 instanceof Array && v2.includes(v1);
+                                            break;
+                                        case 'less-than':
+                                            result = v1 < v2;
+                                            break;
+                                        case 'less-than-equal':
+                                            result = v1 <= v2;
+                                            break;
+                                        case 'greater-than':
+                                            result = v1 > v2;
+                                            break;
+                                        case 'greater-than-equal':
+                                            result = v1 >= v2;
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else {
+                                    console.error('The datatype is not supported');
+                                    result = false;
+                                }
+                                if (result) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!result) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        return array.filter(lamda);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-util.js","sourceRoot":"","sources":["../../../../../../../projects/acorex/core/src/lib/utils/array/array-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXFetchProp } from '../object/object-util';\n\n// @dynamic\nexport class AXArrayUtil {\n\n\n    static pickRandom(array: any[]): any {\n        return array[Math.floor(Math.random() * array.length)];\n    }\n\n\n    static insert(array: any[], index, ...rest) {\n        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));\n        return array;\n    }\n\n    static range(min: number, max: number): number[] {\n        return new Array(max - min).fill(1).map((d, i) => i);\n    }\n\n    static filter(array: any[], filters: any[]): any[] {\n        if (filters == null || filters.length === 0) {\n            return array;\n        }\n        const lamda = (item) => {\n            let result = true;\n            for (const key in filters) {\n                if (filters.hasOwnProperty(key)) {\n                    const f = filters[key];\n                    if (f !== 'AND') {\n                        const vals = [];\n                        const mt = f.field.match(/\\[\\:(.*?)\\]/);\n                        if (mt && mt.length > 1) {\n                            const p1 = f.field.replace(mt[0], '');\n                            const p2 = mt[1];\n                            const prop = AXFetchProp(item, p1);\n                            if (prop instanceof Array && prop.length) {\n                                vals.push(...prop.map(m => (AXFetchProp(m, p2))));\n                            } else {\n                                result = false;\n                            }\n                        } else {\n                            vals.push(AXFetchProp(item, f.field));\n                        }\n                        for (const j in vals) {\n                            if (vals.hasOwnProperty(j)) {\n                                let v1 = vals[j];\n                                const v2 = f.value;\n                                if (f.dataType === 'string') {\n                                    v1 = v1.toString();\n                                    switch (f.condition) {\n                                        case 'equal':\n                                            result = (v1 && v2) && v1.toLowerCase() === v2.toLowerCase();\n                                            break;\n                                        case 'not-equal':\n                                            result = !((v1 && v2) && v1.toLowerCase() === v2.toLowerCase());\n                                            break;\n                                        case 'contains':\n                                            result = ((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));\n                                            break;\n                                        case 'not-contains':\n                                            result = !((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));\n                                            break;\n                                        case 'start-with':\n                                            result = ((v1 && v2) && (v1.toLowerCase().startsWith(v2.toLowerCase())));\n                                            break;\n                                        case 'end-with':\n                                            result = ((v1 && v2) && (v1.toLowerCase().endsWith(v2.toLowerCase())));\n                                            break;\n                                        case 'is-empty':\n                                            result = v1 == null || v1 === undefined;\n                                            break;\n                                        case 'is-not-empty':\n                                            result = !(v1 == null || v1 === undefined);\n                                            break;\n                                        default:\n                                            console.error('The condition is not defined');\n                                            result = false;\n                                    }\n                                } else if (f.dataType === 'date') {\n                                } else if (f.dataType === 'number') {\n                                    v1 = Number(v1);\n                                    switch (f.condition) {\n                                        case 'equal':\n                                            result = v1 === v2;\n                                            break;\n                                        case 'not-equal':\n                                            result = v1 !== v2;\n                                            break;\n                                        case 'contains':\n                                            result = v2 && v2 instanceof Array && v2.includes(v1);\n                                            break;\n                                        case 'less-than':\n                                            result = v1 < v2;\n                                            break;\n                                        case 'less-than-equal':\n                                            result = v1 <= v2;\n                                            break;\n                                        case 'greater-than':\n                                            result = v1 > v2;\n                                            break;\n                                        case 'greater-than-equal':\n                                            result = v1 >= v2;\n                                            break;\n                                        case 'is-empty':\n                                            result = v1 == null || v1 === undefined;\n                                            break;\n                                        case 'is-not-empty':\n                                            result = !(v1 == null || v1 === undefined);\n                                            break;\n                                        default:\n                                            console.error('The condition is not defined');\n                                            result = false;\n                                    }\n                                } else {\n                                    console.error('The datatype is not supported');\n                                    result = false;\n                                }\n                                if (result) {\n                                    break;\n                                }\n                            }\n                        }\n                    }\n                    if (!result) {\n                        return false;\n                    }\n                }\n            }\n            return true;\n        };\n        return array.filter(lamda);\n    }\n\n}\n\n\n\n\n\n"]}