@acorex/core 5.1.2 → 5.1.6

package/src/lib/locale/fa.json

@@ -0,0 +1,244 @@
+{
+    "common": {
+        "search": "جستجو",
+        "yes": "بله",
+        "no": "خیر",
+        "confirm": "تایید",
+        "okay": "تایید",
+        "cancel": "انصراف",
+        "remove": "حذف",
+        "edit": "ویرایش",
+        "configs": "پیکربندی",
+        "noDataFound": "موردی یافت نشد!",
+        "searching": "درحال جستجو ...",
+        "save-as": "ذخیره به عنوان ...",
+        "title": "عنوان",
+        "description": "توضیحات",
+        "name": "نام",
+        "uniquename": "نام شناسه یکتا",
+        "size": "اندازه",
+        "add-item": "افزودن",
+        "color": "رنگ",
+        "display": "نمایش",
+        "value": "مقدار",
+        "min-value": "مقدار کمینه",
+        "max-value": "مقدار بیشینه",
+        "refresh-rate": "نرخ بروز رسانی",
+        "refresh": "بروز رسانی",
+        "reload": "بارگزاری مجدد",
+        "condition":"شرط",
+        "next":"بعدی",
+        "prev":"قبلی"
+    },
+    "dateTime": {
+        "weekdaysShort": {
+            "sun": "ی",
+            "mon": "د",
+            "tue": "س",
+            "wed": "چ",
+            "thu": "پ",
+            "fri": "ج",
+            "sat": "ش"
+        },
+        "dayTime": {
+            "am": "ق ظ",
+            "pm": "ب ظُ",
+            "m": ".ظ",
+            "a": "ق",
+            "p": "ب"
+        },
+        "today": "امروز",
+        "duration": {
+            "format_second": "{0} ثانیه",
+            "format_minute": "{0} دقیقه"
+        }
+    },
+    "queryBuilder": {
+        "contains": "شامل",
+        "not-contains":"به غیر از",
+        "contains-all":"شامل همه",
+        "start-with": "شروع شود با",
+        "end-with": "پایان با",
+        "equal": "برابر با",
+        "not-equal": "نا برابر با",
+        "null": " خالی باشد",
+        "not-null": "خالی نباشد",
+        "greater-than": "بزرگ تر",
+        "gt": "بزرگ تر",
+        "greater-than-equal": "بزرگتر مساوی",
+        "gte": "بزرگتر مساوی",
+        "less-than": "کوچکتر",
+        "lt": "کوچکتر",
+        "less-than-equal": "کوچکتر مساوی",
+        "lte": "کوچکتر مساوی",
+        "true": "true",
+        "false": "false"
+    },
+    "validation": {
+        "messages": {
+            "required": "مقدار این فیلد  الزامی می باشد!",
+            "email": "این آدرس ایمیل معتبر نمی باشد!",
+            "phone": "این شماره تلفن معتبر نمی باشد!"
+        }
+    },
+    "dataGrid": {
+        "page": "صفحه",
+        "more": "بیشتر",
+        "to": "تا",
+        "of": "از",
+        "next": "بعدی",
+        "last": "آخرین",
+        "first": "اولین",
+        "previous": "قبلی",
+        "loadingOoo": "... لطفا منتظر بمانید",
+        "selectAll": "انتخاب همه",
+        "searchOoo": "جستجو ...",
+        "blanks": "جای خالی",
+        "filterOoo": "فیلتر ...",
+        "equals": "برابر",
+        "notEqual": "نابرابر",
+        "lessThan": "کوچکتر از",
+        "greaterThan": "بزرگتر از",
+        "lessThanOrEqual": "کوچکتر مساوی",
+        "greaterThanOrEqual": "بزرکتر مساوی",
+        "inRange": "در محدوده",
+        "inRangeStart": "تا",
+        "inRangeEnd": "از",
+        "contains": "شامل",
+        "notContains": "شامل نمی شود",
+        "startsWith": "شروع شود با",
+        "endsWith": "پایان با",
+        "andCondition": "و",
+        "orCondition": "یا",
+        "applyFilter": "اعمال",
+        "resetFilter": "تنظیم مجدد فیلتر",
+        "clearFilter": "پاک کردن فیلتر",
+        "group": "گروه",
+        "columns": "ستون ها",
+        "filters": "فیاتر ها",
+        "groups": "گروه ها ",
+        "values": "مقدار ها",
+        "enabled": "فعال شده",
+        "pinColumn": "سنجاق",
+        "groupBy": "دسته بندی بر اساس",
+        "ungroupBy": "حذف دسته بندی",
+        "resetColumns": "تنظیم مجدد ستون ها",
+        "expandAll": "باز کردن همه",
+        "collapseAll": "بستن همه",
+        "toolPanel": "پنل ابزار",
+        "export": "خروجی",
+        "csvExport": "csv خروجی",
+        "excelExport": "خروجی اکسل (.xlsx)",
+        "excelXmlExport": "خروجی اکسل (.xml)",
+        "chartRange": "محدوده نمودار",
+        "columnChart": "ستون",
+        "groupedColumn": "دسته بندی شده",
+        "stackedColumn": "انباشته",
+        "normalizedColumn": "ستون نرمال",
+        "barChart": "نمودار میله ای",
+        "groupedBar": "دسته بندی شده",
+        "stackedBar": "انباشته",
+        "normalizedBar": "نوار ",
+        "pie": "پای",
+        "doughnut": "Doughnut",
+        "line": "خط",
+        "xyChart": "X Y (پراکندگی)",
+        "scatter": "پراکندگی",
+        "bubble": "حباب",
+        "areaChart": "حوزه",
+        "area": "حوزه",
+        "stackedArea": "انباشته ",
+        "normalizedArea": "100% انباشته",
+        "histogramChart": "هیستوگرام",
+        "pinLeft": "سنجاق چپ",
+        "pinRight": "سنجاق راست",
+        "noPin": "حذف سنجاق",
+        "sum": "مجموع",
+        "min": "مینیمم",
+        "max": "ماکزیمم",
+        "none": "هیچ",
+        "count": "شمردن",
+        "avg": "میانگین",
+        "filteredRows": "فیلتر شده",
+        "selectedRows": "انتخاب شده",
+        "totalRows": "مجموع ردیف ها",
+        "totalAndFilteredRows": "سطر ها",
+        "copy": "کپی",
+        "copyWithHeaders": "کپی با هدر ها",
+        "ctrlC": "Ctrl C",
+        "paste": "جایگزینی",
+        "ctrlV": "Ctrl V",
+        "pivotChartTitle": "نمودار محوری",
+        "rangeChartTitle": "نمودار محدوده",
+        "settings": "تنظیمات",
+        "data": "تاریخ",
+        "format": "قالب",
+        "categories": "دسته بندی ها",
+        "series": "Series",
+        "xyValues": "X Y مقادیر",
+        "paired": "حالت زوج",
+        "axis": "محور",
+        "color": "رنگ",
+        "thickness": "ضخامت",
+        "xType": "X Type",
+        "automatic": "خودکار",
+        "category": "دسته بندی",
+        "number": "عدد",
+        "time": "زمان",
+        "xRotation": "X چرخش",
+        "yRotation": "Y چرخش",
+        "ticks": "نمادها",
+        "width": "عرض",
+        "length": "طول",
+        "padding": "لایه گزاری",
+        "chart": "جدول",
+        "title": "عنوان",
+        "background": "زمینه",
+        "font": "فونت",
+        "top": "بالا",
+        "right": "راست",
+        "bottom": "پایین",
+        "left": "چپ",
+        "labels": "برچسب",
+        "size": "اندازه",
+        "minSize": "حداقل اندازه",
+        "maxSize": "بیشترین اندازه",
+        "position": "موقعیت",
+        "markerSize": "اندازه نشانگر",
+        "callout": "فراخوان",
+        "markers": "نشانه گرها",
+        "shadow": "سایه",
+        "blur": "محو شدن",
+        "xOffset": "X انحراف",
+        "yOffset": "Y انحراف",
+        "lineWidth": "عرض خط",
+        "normal": "نرمال",
+        "italic": "Italic",
+        "boldItalic": "Bold Italic",
+        "predefined": "Predefined",
+        "fillOpacity": "Fill Opacity",
+        "strokeOpacity": "Line Opacity",
+        "histogramBinCount": "Bin Count",
+        "columnGroup": "ستون",
+        "barGroup": "Bar",
+        "pieGroup": "Pie",
+        "lineGroup": "خط",
+        "areaGroup": "حوزه",
+        "histogramGroup": "هیستوگرام",
+        "groupedColumnTooltip": "دسته بندی شده",
+        "stackedColumnTooltip": "Stacked",
+        "normalizedColumnTooltip": "100% Stacked",
+        "groupedBarTooltip": "دسته بندی شده",
+        "stackedBarTooltip": "Stacked",
+        "pieTooltip": "Pie",
+        "doughnutTooltip": "Doughnut",
+        "lineTooltip": "خط",
+        "groupedAreaTooltip": "گروه بندی شده",
+        "stackedAreaTooltip": "Stacked",
+        "scatterTooltip": "Scatter",
+        "bubbleTooltip": "حباب",
+        "histogramTooltip": "هیستوگرام",
+        "autosizeThiscolumn": "تنظیم اندازه ستون ",
+        "autosizeAllColumns": "تنظیم اندازه همه ستون ها"
+    }
+}

package/src/lib/pipe/datetime.pipe.ts

@@ -0,0 +1,20 @@
+import { PipeTransform, Pipe } from '@angular/core';
+import { AXDateTime } from '../classes/datetime.class';
+
+@Pipe({ name: 'dt' })
+export class AXDateTimePipe implements PipeTransform {
+    constructor() { }
+
+    transform(value: any, format?: string): string {
+        const date: AXDateTime = AXDateTime.convert(value);
+        if (value == null) {
+            return '';
+        }
+        if (!format) {
+            return date.toString();
+        }
+        else {
+            return date.format(format);
+        }
+    }
+}

package/src/lib/pipe/htmlToText.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'html2text' })
+export class AXHtmlToTextPipe implements PipeTransform {
+  transform(value: string) {
+    if (value) {
+      const regexHtml = /<\/?[^>]+>/gi;
+      const regexNbsp = /&nbsp;/gi;
+      const regexAmp = /&amp;/gi;
+      return value
+        .replace(regexHtml, '')
+        .replace(regexNbsp, '')
+        .replace(regexAmp, '');
+    } else {
+      return '';
+    }
+  }
+}

package/src/lib/platform/index.ts

@@ -0,0 +1 @@
+export * from './platform.service';

package/src/lib/platform/platform.service.ts

@@ -0,0 +1,211 @@
+import { Injectable } from "@angular/core";
+import { from, fromEvent, Subject } from "rxjs";
+import { debounceTime, distinctUntilChanged } from "rxjs/operators";
+
+
+export type AXPlatforms = 'Android' | 'Desktop' | 'iOS' | 'Mobile';
+export type AXBrowsers = 'Chrome' | 'Safari' | 'Edge' | 'Firefox' | 'Opera' | 'MSIE';
+export type AXTechnologies = 'PWA' | 'Hybrid' | 'Electron';
+
+
+
+
+const isChrome = (win: Window): boolean =>
+    testUserAgent(win, /Chrome/i);
+
+const isFirefox = (win: Window): boolean =>
+    testUserAgent(win, /Firefox/i);
+
+const isEdge = (win: Window): boolean =>
+    testUserAgent(win, /Edge/i);
+
+const isSafari = (win: Window): boolean =>
+    testUserAgent(win, /Safari/i);
+
+const isOpera = (win: Window): boolean =>
+    testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);
+
+const isMSIE = (win: Window): boolean =>
+    testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);
+
+
+const isMobileWeb = (win: Window): boolean =>
+    isMobile(win) && !isHybrid(win);
+
+const isIpad = (win: Window) => {
+    // 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: Window) =>
+    testUserAgent(win, /iPhone/i);
+
+const isIOS = (win: Window) =>
+    testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
+
+const isAndroid = (win: Window) =>
+    testUserAgent(win, /android|sink/i);
+
+const isAndroidTablet = (win: Window) => {
+    return isAndroid(win) && !testUserAgent(win, /mobile/i);
+};
+
+const isPhablet = (win: Window) => {
+    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: Window) => {
+    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: Window) =>
+    matchMedia(win, '(any-pointer:coarse)');
+
+const isDesktop = (win: Window) =>
+    !isMobile(win);
+
+const isHybrid = (win: Window) =>
+    isCordova(win) || isCapacitorNative(win);
+
+const isCordova = (win: any): boolean =>
+    !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);
+
+const isCapacitorNative = (win: any): boolean => {
+    const capacitor = win['Capacitor'];
+    return !!(capacitor && capacitor.isNative);
+};
+
+const isElectron = (win: Window): boolean =>
+    testUserAgent(win, /electron/i);
+
+const isPWA = (win: Window): boolean =>
+    !!(win.matchMedia('(display-mode: standalone)').matches || (win.navigator as any).standalone);
+
+export const testUserAgent = (win: Window, expr: RegExp) =>
+    expr.test(win.navigator.userAgent);
+
+const matchMedia = (win: Window, query: string): boolean =>
+    win.matchMedia(query).matches;
+
+
+const PLATFORMS_MAP = {
+    'Android': isAndroid,
+    'iOS': isIOS,
+    'Desktop': isDesktop,
+    'Mobile': isMobile,
+    'Chrome': isChrome,
+    'Firefox': isFirefox,
+    'Safari': isSafari,
+    'Edge': isEdge,
+    'Opera': isOpera,
+    'Hybrid': isHybrid,
+    'PWA': isPWA,
+    'Electron': isElectron,
+};
+
+
+export class AXPlatformEvent {
+    nativeEvent: UIEvent | Event;
+    source: AXPlatform
+}
+
+@Injectable({
+    providedIn: 'platform',
+})
+export class AXPlatform {
+    resize: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>();
+    click: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>()
+    scroll: Subject<AXPlatformEvent> = new Subject<AXPlatformEvent>()
+
+    isRtl(): boolean {
+        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
+    }
+
+
+    isLandscape(): boolean {
+        return window.innerHeight < window.innerWidth;
+    }
+
+    isPortrate(): boolean {
+        return !this.isLandscape()
+    }
+
+    is(name: AXPlatforms | AXBrowsers | AXTechnologies): boolean {
+        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')
+    }
+
+    private _setFullHeightRatio() {
+        document.querySelector<HTMLElement>(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');
+    }
+
+    constructor() {
+
+        fromEvent<UIEvent>(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();
+    }
+}

package/src/lib/services/config.ts

@@ -0,0 +1,36 @@
+import { Subject, Observable } from 'rxjs';
+import { getPropByPath, setPropByPath } from '../utils/object/object-util';
+
+// @dynamic
+export class AXConfig {
+    private static dataModel: any = {};
+    private static dataChangeSubject = new Subject<any>();
+
+
+    static get onChange(): Observable<any> {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+
+    static set(config: any): any;
+    static set(path: string, value?: any): void;
+    static set(arg1?: any, arg2?: any) {
+
+        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: string): any {
+        return getPropByPath(AXConfig.dataModel, path);
+    }
+}

package/src/lib/services/event.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class AXEventService {
+    private list: any[] = [];
+
+    public broadcast(key: string, options?: any): void {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events.forEach(c => {
+                c(options);
+            });
+        }
+    }
+
+    public on(key: string, callback: (options?: any) => void) {
+        let d = this.list.find(c => c.key === key);
+        if (!d) {
+            d = { key, events: [] };
+            this.list.push(d);
+        }
+        d.events.push(callback);
+    }
+
+    public destroy(key: string, callback: (options?: any) => void): void {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events = [];
+        }
+    }
+}

package/src/lib/services/navigator.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@angular/core';
+import { AXNavigatorParam } from '../classes/navigator.class';
+
+@Injectable()
+export abstract class AXNavigator {
+    abstract navigate(params: AXNavigatorParam);
+    abstract popup(params: AXNavigatorParam);
+}

package/src/lib/services/storage.service.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class AXStorageService {
+   get(key: string): any {
+      return localStorage.getItem(key) as any;
+   }
+   set(key: string, value: any): void {
+      localStorage.setItem(key, value as string);
+   }
+}

package/src/lib/translator/translator.module.ts

@@ -0,0 +1,19 @@
+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';
+
+
+@NgModule({
+    imports: [],
+    exports: [AXTranslatorPipe],
+    declarations: [AXTranslatorPipe],
+    providers: [],
+})
+export class AXTranslatorModule {
+    constructor() {
+        AXTranslator.load('en', en);
+        AXTranslator.load('fa', fa);
+    }
+}

package/src/lib/translator/translator.pipe.ts

@@ -0,0 +1,22 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { AXTranslator } from './translator';
+
+@Pipe({ name: 'trans', pure: true })
+export class AXTranslatorPipe implements PipeTransform {
+
+    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: string, lang?: string): string {
+        return AXTranslator.get(value, lang);
+    }
+}

package/src/lib/translator/translator.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { AXTranslator } from './translator';
+
+@Injectable({ providedIn: 'platform' })
+export class AXTranslatorService {
+
+    public load(lang: string, value: any) {
+        AXTranslator.load(lang, value);
+    }
+
+    public use(lang: string) {
+        AXTranslator.use(lang);
+    }
+
+    public get(key: string, lang?: string): string {
+        return AXTranslator.get(lang, lang);
+    }
+}
+

package/src/lib/translator/translator.ts

@@ -0,0 +1,31 @@
+import { Subject, Observable } from 'rxjs';
+import { getPropByPath} from '../utils/object/object-util';
+import merge from 'lodash-es/merge';
+
+// @dynamic
+export class AXTranslator {
+    private static lang: string = 'en';
+    private static dataChangeSubject = new Subject<any>();
+
+
+    static get onChange(): Observable<any> {
+        return AXTranslator.dataChangeSubject.asObservable();
+    }
+
+    public static load(lang: string, value: any) {
+        if (typeof value === 'object') {
+            if (!AXTranslator[`__data__${lang}`]) {
+                AXTranslator[`__data__${lang}`] = {};
+            }
+            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
+        }
+    }
+
+    public static use(lang: string) {
+        AXTranslator.lang = lang;
+    }
+
+    public static get(key: string, lang?: string): string {
+        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+    }
+}