@acorex/core 6.5.13 → 6.5.14

package/src/lib/error/error.service.ts

@@ -0,0 +1,23 @@
+import { InjectionToken, Injectable, Injector } from '@angular/core';
+
+export const  AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken<AXErrorDisplayInterceptor>('ax.error');
+
+export interface AXErrorDisplayInterceptor {
+    show(message: string);
+}
+
+@Injectable({providedIn: 'root'})
+export class AXErrorService {
+
+    constructor(private injector: Injector) {
+
+    }
+
+    handle(message: string) {
+        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
+        if (instance) {
+            instance.show(message);
+        }
+    }
+
+}

package/src/lib/error/index.ts

@@ -0,0 +1,3 @@
+export * from './error.class';
+export * from './error.service';
+export * from './error.module';

package/{lib/events/keyboard.d.ts → src/lib/events/keyboard.ts}

@@ -1,2 +1,5 @@
+
+// tslint:disable-next-line: no-empty-interface
 export interface AXKeyboardEvent extends KeyboardEvent {
+
 }

package/{lib/http/http-error.class.d.ts → src/lib/http/http-error.class.ts}

@@ -3,5 +3,5 @@ export interface IHttpError {
     status?: number;
     code?: string;
     handled: boolean;
-    error: any | null;
-}
+    error: any | null
+}

package/{lib/http/http-events.interceptor.d.ts → src/lib/http/http-events.interceptor.ts}

@@ -1,10 +1,14 @@
 import { IHttpError } from './http-error.class';
 import { InjectionToken } from '@angular/core';
 import { AXHttpRequestOptions } from './http-request.class';
-export declare const AX_HTTP_EVENT_INTERCEPTOR: InjectionToken<AXHttpEventInterceptor>;
+
+export const AX_HTTP_EVENT_INTERCEPTOR = new InjectionToken<AXHttpEventInterceptor>('ax.http.events');
+
 export interface AXHttpEventInterceptor {
     begin(request: AXHttpRequestOptions): Promise<AXHttpRequestOptions>;
     success(request: AXHttpRequestOptions, result: any): Promise<any>;
-    complete(request: AXHttpRequestOptions): any;
-    error(request: AXHttpRequestOptions, error: IHttpError): any;
+    complete(request: AXHttpRequestOptions);
+    error(request: AXHttpRequestOptions, error: IHttpError);
 }
+
+

package/{lib/http/http-request.class.d.ts → src/lib/http/http-request.class.ts}

@@ -1,14 +1,14 @@
 export interface AXHttpRequestOptions {
-    url?: any;
+    url?: any,
     params?: {
         [param: string]: any;
-    };
+    },
     body?: {
         [param: string]: any;
-    };
+    },
     headers?: {
         [header: string]: any;
-    };
+    },
     method?: 'get' | 'post' | 'put' | 'delete';
     responseType?: any;
-}
+}

package/src/lib/http/http-result.class.ts

@@ -0,0 +1,34 @@
+import { IHttpError } from './http-error.class';
+
+export class HttpResult<T> {
+    private _executor: (result: (e?: T) => void, error: (e?: IHttpError) => void, complete: () => void) => void;
+    constructor(
+        executor: (
+            result: (e?: T) => void,
+            error: (e?: IHttpError) => void,
+            complete: () => void
+        ) => void
+    ) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.resultAction, this.errorAction, this.completeAction);
+        }, 50);
+    }
+
+    private resultAction: (e?: T) => void;
+    private errorAction: (e?: IHttpError) => void;
+    private completeAction: () => void;
+
+    result(action: (e?: T) => void): HttpResult<T> { 
+        this.resultAction = action;
+        return this;
+    }
+    error(action: (e?: IHttpError) => void): HttpResult<T> {
+        this.errorAction = action;
+        return this;
+    }
+    complete(action: () => void): HttpResult<T> {
+        this.completeAction = action;
+        return this;
+    }
+}

package/src/lib/http/http.module.ts

@@ -0,0 +1,25 @@
+import { NgModule, ModuleWithProviders } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { AXHttpService } from './http.service';
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule,
+    HttpClientModule
+  ],
+  exports: [HttpClientModule],
+  providers: [
+    AXHttpService
+  ]
+})
+export class AXHttpModule {
+  static forRoot(): ModuleWithProviders<AXHttpModule> {
+    return {
+      ngModule: AXHttpModule,
+      providers: [AXHttpService]
+    };
+  }
+}

package/src/lib/http/http.service.ts

@@ -0,0 +1,159 @@
+import { Injectable, Injector, InjectFlags } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';
+import { HttpResult } from './http-result.class';
+import { IHttpError } from './http-error.class';
+import { AXHttpRequestOptions } from './http-request.class';
+import {
+    AX_HTTP_EVENT_INTERCEPTOR, AXHttpEventInterceptor
+} from './http-events.interceptor';
+// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
+// import { of, concat, throwError } from 'rxjs';
+
+
+@Injectable()
+export class AXHttpService {
+
+    private interceptor: AXHttpEventInterceptor;
+    constructor(private http: HttpClient, private injector: Injector) {
+        this.interceptor = this.injector.get(AX_HTTP_EVENT_INTERCEPTOR);
+    }
+
+
+    get<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "get";
+        return this.request(config);
+    }
+
+    post<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "post";
+        return this.request(config);
+    }
+
+    delete<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "delete";
+        return this.request(config);
+    }
+
+    put<T>(url: string, config: AXHttpRequestOptions = {}): HttpResult<T> {
+        config.url = url;
+        config.method = "put";
+        return this.request(config);
+    }
+
+
+    request<T>(config: AXHttpRequestOptions): HttpResult<T> {
+        return new HttpResult<T>((result?, error?, complete?) => {
+            this.handleBegin(config).then(c => {
+                this.http
+                    .request<T>(config.method, config.url, this.mapOptions(config))
+                    //.pipe(this.retry)
+                    .subscribe(data => {
+                        this.handleResult(data, result, complete, config);
+                    }, c => {
+                        this.handleError(c, error, complete, config);
+                    });
+            });
+        })
+    }
+
+
+    private handleResult(data, result, complete, config: AXHttpRequestOptions) {
+        if (this.interceptor) {
+            this.interceptor.success(config, data).then(c => {
+                if (result)
+                    result(c);
+                this.handleComplete(complete, config);
+            });
+        }
+        else {
+            //
+            if (result)
+                result(data);
+            this.handleComplete(complete, config);
+        }
+    }
+
+    private handleBegin(config: AXHttpRequestOptions): Promise<AXHttpRequestOptions> {
+        return new Promise((resolve) => {
+            if (!config.headers)
+                config.headers = {};
+            if (!config.params)
+                config.params = {};
+            //
+            if (this.interceptor) {
+                this.interceptor.begin(config).then(c => {
+                    resolve(c);
+                });
+            }
+            else {
+                resolve(config)
+            }
+        })
+    }
+
+    private handleComplete(complete: Function, config: AXHttpRequestOptions) {
+        if (complete)
+            complete();
+        if (this.interceptor)
+            this.interceptor.complete(config);
+    }
+
+    private handleError(c: HttpErrorResponse, error: Function, complete: Function, config: AXHttpRequestOptions) {
+        let r: IHttpError = {
+            message: c.message,
+            status: c.status,
+            code: c.status?.toString(),
+            handled: false,
+            error: c.error
+        }
+        if (error) {
+            error(r);
+        }
+        if (!r.handled) {
+            if (this.interceptor)
+                this.interceptor.error(config, r);
+        }
+        this.handleComplete(complete, config);
+    }
+
+    private mapOptions(options: AXHttpRequestOptions) {
+        let headers = new HttpHeaders();
+
+        for (const key in options.headers) {
+            if (options.headers.hasOwnProperty(key)) {
+                const value = options.headers[key];
+                headers = headers.set(key, value)
+            }
+        }
+        let params = new HttpParams();
+        for (const key in options.params) {
+            if (options.params.hasOwnProperty(key)) {
+                const value = options.params[key];
+                params = params.set(key, value);
+            }
+        }
+        return {
+            headers: headers,
+            params: params,
+            body: options.body,
+            responseType: options.responseType || 'json'
+        };
+        // if (options.method == "get") {
+        //     return {
+        //         headers: headers,
+        //         params: params
+        //     };
+        // }
+        // else {
+        //     return {
+        //         headers: headers,
+        //         params: params,
+        //         body: options.body
+        //     };
+        // }
+    }
+
+}

package/{esm2020 → src}/lib/locale/en.json

@@ -27,9 +27,9 @@
         "refresh-rate": "Refresh Rate",
         "refresh": "Refresh",
         "reload": "Reload",
-        "condition": "Condition",
-        "next": "Next",
-        "prev": "Prev"
+        "condition":"Condition",
+        "next":"Next",
+        "prev":"Prev"
     },
     "dateTime": {
         "weekdaysShort": {
@@ -56,8 +56,8 @@
     },
     "queryBuilder": {
         "contains": "contains",
-        "not-contains": "not-contains",
-        "contains-all": "contains-all",
+        "not-contains":"not-contains",
+        "contains-all":"contains-all",
         "start-with": "start-with",
         "end-with": "end-with",
         "equal": "equal",
@@ -252,4 +252,4 @@
         "bubbleTooltip": "Bubble",
         "histogramTooltip": "Histogram"
     }
-}
+}

package/{esm2020 → src}/lib/locale/fa.json

@@ -26,10 +26,10 @@
         "refresh-rate": "نرخ بروز رسانی",
         "refresh": "بروز رسانی",
         "reload": "بارگزاری مجدد",
-        "condition": "شرط",
-        "next": "بعدی",
-        "prev": "قبلی",
-        "reset": "بازنشانی"
+        "condition":"شرط",
+        "next":"بعدی",
+        "prev":"قبلی",
+        "reset":"بازنشانی"
     },
     "dateTime": {
         "weekdaysShort": {
@@ -56,8 +56,8 @@
     },
     "queryBuilder": {
         "contains": "شامل",
-        "not-contains": "به غیر از",
-        "contains-all": "شامل همه",
+        "not-contains":"به غیر از",
+        "contains-all":"شامل همه",
         "start-with": "شروع شود با",
         "end-with": "پایان با",
         "equal": "برابر با",
@@ -242,4 +242,4 @@
         "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 = [];
+        }
+    }
+}