@acorex/core 6.5.26 → 6.5.27

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;
+    }
+}

package/src/lib/utils/array/array-util.ts

@@ -0,0 +1,140 @@
+import { AXFetchProp } from '../object/object-util';
+
+// @dynamic
+export class AXArrayUtil {
+
+
+    static pickRandom(array: any[]): any {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+
+
+    static insert(array: any[], index, ...rest) {
+        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));
+        return array;
+    }
+
+    static range(min: number, max: number): number[] {
+        return new Array(max - min).fill(1).map((d, i) => i);
+    }
+
+    static filter(array: any[], filters: any[]): any[] {
+        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);
+    }
+
+}
+
+
+
+
+

package/src/lib/utils/html/html-util.ts

@@ -0,0 +1,264 @@
+import { AXMathUtil } from '../math/math-util';
+
+export type AXPlacement =
+  | 'top-start'
+  | 'top-middle'
+  | 'top-end'
+  | 'center-start'
+  | 'center-end'
+  | 'bottom-start'
+  | 'bottom-middle'
+  | 'bottom-end';
+
+export interface AXIPoint {
+  x: number;
+  y: number;
+}
+
+export interface AXConnectedPosition {
+  originX: 'start' | 'center' | 'end';
+  originY: 'top' | 'center' | 'bottom';
+  overlayX: 'start' | 'center' | 'end';
+  overlayY: 'top' | 'center' | 'bottom';
+  weight?: number;
+  offsetX?: number;
+  offsetY?: number;
+}
+
+export class AXPoint implements AXIPoint {
+  constructor(public x: number, public y: number) {
+  }
+}
+
+export interface AXClientRecCtor {
+  left?: number;
+  top?: number;
+  width?: number;
+  height?: number;
+  bottom?: number;
+  right?: number;
+}
+export class AXClientRec implements AXClientRecCtor {
+
+
+  private _left: number;
+  public get left(): number {
+    return this._left;
+  }
+  public set left(v: number) {
+    this._left = v;
+  }
+
+
+  private _top: number;
+  public get top(): number {
+    return this._top;
+  }
+  public set top(v: number) {
+    this._top = v;
+  }
+
+
+  private _right: number;
+  public get right(): number {
+    return this._right;
+  }
+  public set right(v: number) {
+    this._right = v;
+  }
+
+
+  private _bottom: number;
+  public get bottom(): number {
+    return this._bottom;
+  }
+  public set bottom(v: number) {
+    this._bottom = v;
+  }
+
+
+
+  private _width: number;
+  public get width(): number {
+    return this._width;
+  }
+  public set width(v: number) {
+    this._width = v;
+  }
+
+
+  private _height: number;
+  public get height(): number {
+    return this._height;
+  }
+  public set height(v: number) {
+    this._height = v;
+  }
+
+
+  constructor(rec: AXClientRecCtor) {
+    this._left = rec.left;
+    this._top = rec.top;
+    this._width = rec.width;
+    this._height = rec.height;
+    this._right = this._left + this._width;
+    this._bottom = this._top + this._height;
+  }
+
+  public intersect(rec: AXClientRecCtor): boolean {
+    return (this.left < rec.left + rec.width &&
+      this.left + this.width > rec.left &&
+      this.top < rec.top + rec.height &&
+      this.top + this.height > rec.top);
+  }
+
+
+}
+// @dynamic
+export class AXHtmlUtil {
+  static getBoundingRectPoint(el: HTMLElement, placement: AXPlacement): AXPoint {
+    const rec = el.getBoundingClientRect();
+    const width = el.offsetWidth;
+    const height = el.offsetHeight;
+    switch (placement) {
+      case 'top-start':
+        return new AXPoint(rec.left, rec.top);
+      case 'top-middle':
+        return new AXPoint(rec.left + (width / 2), rec.top);
+      case 'top-end':
+        return new AXPoint(rec.left + (width), rec.top);
+      case 'center-end':
+        return new AXPoint(rec.left + (width), rec.top + (height / 2));
+      case 'bottom-end':
+        return new AXPoint(rec.left + (width), rec.top + (height));
+      case 'bottom-middle':
+        return new AXPoint(rec.left + (width / 2), rec.top + (height));
+      case 'bottom-start':
+        return new AXPoint(rec.left, rec.top + (height));
+      case 'center-start':
+        return new AXPoint(rec.left, rec.top + (height / 2));
+      default:
+        return new AXPoint(rec.left + (width / 2), rec.top + (height));
+    }
+  }
+
+  static isInRecPoint(pos: AXIPoint, rec: AXClientRecCtor): boolean {
+    return pos.x >= rec.left && pos.x <= (rec.left + rec.width) && pos.y >= rec.top && (pos.y <= (rec.top + rec.height));
+  }
+
+  // static isOverLap(rec1: AXClientRecCtor, rec2: AXClientRecCtor): boolean {
+  //   const r1: AXClientRec = new AXClientRec(rec1);
+  //   const r2: AXClientRec = new AXClientRec(rec2);
+
+  //   return ;
+  // }
+
+  static isInElementBound(pos: AXIPoint, element: HTMLElement): boolean {
+    const elBound = element.getBoundingClientRect();
+    return AXHtmlUtil.isInRecPoint(pos, {
+      left: elBound.left,
+      width: elBound.width,
+      top: elBound.top,
+      height: elBound.height
+    });
+  }
+
+  static getDimensions(): { width: number, height: number } {
+    let winW = 630;
+    let winH = 460;
+    if (document.body && document.body.offsetWidth) {
+      winW = document.body.offsetWidth;
+      winH = document.body.offsetHeight;
+    }
+    if (document.compatMode === 'CSS1Compat' && document.documentElement && document.documentElement.offsetWidth) {
+      winW = document.documentElement.offsetWidth;
+      winH = document.documentElement.offsetHeight;
+    }
+    if (window.innerWidth && window.innerHeight) {
+      winW = window.innerWidth;
+      winH = window.innerHeight;
+    }
+    return { width: winW, height: winH };
+  }
+
+  static getOffsetRight(elem: HTMLElement): number {
+    let element = elem;
+    const width = element.offsetWidth;
+    let right = 0;
+    while (element.offsetParent) {
+      right += element.offsetLeft;
+      element = element.offsetParent as HTMLElement;
+    }
+    right += element.offsetLeft;
+    right = AXHtmlUtil.getDimensions().width - right;
+    right -= width;
+    return right;
+  }
+
+  static getUID(): string {
+    return 'el-' + AXMathUtil.randomRange(1000000000, 9999999999).toString();
+  }
+
+
+  static getRelatedPosition(source: HTMLElement, placement: AXPlacement, target: HTMLElement, alignment: AXPlacement): AXIPoint {
+    const result: AXIPoint = { x: 0, y: 0 };
+
+    const sourcePos: AXPoint = AXHtmlUtil.getBoundingRectPoint(source, placement);
+
+
+    let top: number = 0;
+    let left: number = 0;
+    switch (alignment) {
+      case 'top-start':
+        top = sourcePos.y;
+        left = sourcePos.x;
+        break;
+      case 'top-middle':
+        top = sourcePos.y;
+        left = sourcePos.x - target.offsetWidth / 2;
+        break;
+      case 'top-end':
+        top = sourcePos.y;
+        left = sourcePos.x - target.offsetWidth;
+        break;
+      case 'center-end':
+        top = sourcePos.y - target.offsetHeight / 2;
+        left = sourcePos.x - target.offsetWidth;
+        break;
+      case 'bottom-end':
+        top = sourcePos.y - target.offsetHeight;
+        left = sourcePos.x - target.offsetWidth;
+        break;
+      case 'bottom-middle':
+        top = sourcePos.y - target.offsetHeight;
+        left = sourcePos.x - target.offsetWidth / 2;
+        break;
+      case 'bottom-start':
+        top = sourcePos.y - target.offsetHeight;
+        left = sourcePos.x;
+        break;
+      case 'center-start':
+        top = sourcePos.y - target.offsetHeight / 2;
+        left = sourcePos.x;
+        break;
+    }
+    result.y = top;
+    result.x = left;
+    return result;
+  }
+
+
+  static collision(a: HTMLElement, b: HTMLElement): boolean {
+    const ac = a.getBoundingClientRect();
+    const bc = b.getBoundingClientRect();
+
+    if (ac.left < bc.left + bc.width && ac.left + ac.width > bc.left &&
+      ac.top < bc.top + bc.height && ac.top + ac.height > bc.top) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+
+}

package/src/lib/utils/html/html.module.ts

@@ -0,0 +1,11 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AXHtmlToTextPipe } from '../../pipe/htmlToText.pipe';
+
+@NgModule({
+  declarations: [AXHtmlToTextPipe],
+  imports: [CommonModule],
+  exports: [AXHtmlToTextPipe],
+  providers: []
+})
+export class AXHtmlModule { }

package/src/lib/utils/math/math-util.ts

@@ -0,0 +1,5 @@
+export class AXMathUtil {
+    static randomRange(min: number, max: number): number {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+}

package/src/lib/utils/object/object-util.ts

@@ -0,0 +1,87 @@
+// @dynamic
+export class AXObjectUtil {
+    static deepJSONClone(obj: any): any {
+        return obj ? JSON.parse(JSON.stringify(obj)) : null;
+    }
+
+    static deepCopy(obj) {
+        let copy;
+        // Handle the 3 simple types, and null or undefined
+        if (null == obj || 'object' !== typeof obj) { return obj; }
+        // Handle Date
+        if (obj instanceof Date) {
+            copy = new Date();
+            copy.setTime(obj.getTime());
+            return copy;
+        }
+        // Handle Array
+        if (obj instanceof Array) {
+            copy = [];
+            for (let i = 0, len = obj.length; i < len; i++) {
+                copy[i] = AXObjectUtil.deepCopy(obj[i]);
+            }
+            return copy;
+        }
+        // Handle Object
+        if (obj instanceof Object) {
+            copy = {};
+            for (const attr in obj) {
+                if (obj.hasOwnProperty(attr)) { copy[attr] = AXObjectUtil.deepCopy(obj[attr]); }
+            }
+            return copy;
+        }
+        throw new Error('Unable to copy obj! Its type isn\'t supported.');
+    }
+}
+
+export function AXFetchProp(obj, prop: string) {
+    if (typeof obj === 'undefined') {
+        return false;
+    }
+    const index = prop.indexOf('.');
+
+    if (index > -1) {
+        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+    }
+
+    return obj[prop];
+}
+
+
+
+
+export function getPropByPath(obj, path, defaultVal?) {
+    path = path
+        .replace(/\[/g, '.')
+        .replace(/]/g, '')
+        .split('.');
+
+    path.forEach((level) => {
+        if (obj) {
+            obj = obj[level];
+        }
+    });
+
+    if (obj === undefined) {
+        return defaultVal;
+    }
+    return obj;
+}
+
+export function setPropByPath(obj, path, value) {
+    if (Object(obj) !== obj) { return obj; } // When obj is not an object
+    // If not yet an array, get the keys from the string-path
+    if (!Array.isArray(path)) { path = path.toString().match(/[^.[\]]+/g) || []; }
+    path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
+        Object(a[c]) === a[c] // Does the key exist and is its value an object?
+            // Yes: then follow that path
+            ? a[c]
+            // No: create the key. Is the next key a potential array-index?
+            : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
+                ? [] // Yes: assign a new array object
+                : {}, // No: assign a new plain object
+        obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
+    return obj[path[0]]; // Return the top-level object to allow chaining
+}
+
+

package/src/lib/utils/render/on-demand-preload-strategy.service.ts

@@ -0,0 +1,25 @@
+import { PreloadingStrategy, Route } from '@angular/router';
+import { Injectable } from '@angular/core';
+import { Subject, Observable, of } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import { AXHtmlUtil } from '../html/html-util';
+
+
+
+
+@Injectable()
+export class AXOnDemandPreloadService {
+  subject = new Subject<string>();
+  tmp: string;
+
+  constructor() {
+    this.tmp = AXHtmlUtil.getUID();
+  }
+
+  startPreload(routePath: string) {
+    const slices: string[] = [];
+   
+
+    this.subject.next(routePath);
+  }
+}