@acorex/core 6.5.28 → 6.5.30

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

@@ -1,159 +0,0 @@
-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/src/lib/pipe/datetime.pipe.ts

@@ -1,20 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,223 +0,0 @@
-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';
-export type AXScreenSizes = 'SM' | 'MD' | 'LG' | 'XL' | '2XL';
-
-
-
-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 isTouch = (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 isSMScreen = (win: Window) => matchMedia(win, '(max-width: 640px)');
-const isMDScreen = (win: Window) => matchMedia(win, '(max-width: 768px)');
-const isLGScreen = (win: Window) => matchMedia(win, '(max-width: 1024px)');
-const isXLScreen = (win: Window) => matchMedia(win, '(max-width: 1280px)');
-const is2XLScreen = (win: Window) => 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 {
-    nativeEvent: UIEvent | Event;
-    source: AXPlatform
-}
-
-@Injectable({
-    providedIn: 'root',
-})
-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 | AXScreenSizes): 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

@@ -1,36 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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;
-    }
-}