@acorex/core 5.8.0 → 6.0.1

package/http/public-api.ts

@@ -0,0 +1,5 @@
+export * from './src/http-error.class';
+export * from './src/http-events.interceptor';
+export * from './src/http-request.class';
+export * from './src/http-result.class';
+export * from './src/http.module';

package/http/src/http-error.class.ts

@@ -0,0 +1,7 @@
+export interface IHttpError {
+    message?: string;
+    status?: number;
+    code?: string;
+    handled: boolean;
+    error: any | null
+}

package/http/src/http-events.interceptor.ts

@@ -0,0 +1,14 @@
+import { IHttpError } from './http-error.class';
+import { InjectionToken } from '@angular/core';
+import { AXHttpRequestOptions } from './http-request.class';
+
+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);
+    error(request: AXHttpRequestOptions, error: IHttpError);
+}
+
+

package/http/src/http-request.class.ts

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

package/http/src/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/http/src/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 {
+  //   return {
+  //     ngModule: AXHttpModule,
+  //     providers: [AXHttpService]
+  //   };
+  // }
+}

package/http/src/http.service.ts

@@ -0,0 +1,161 @@
+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
+                    //TODO: check ts error
+                    //@ts-ignore
+                    .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/index.ts

@@ -0,0 +1 @@
+export * from './public-api'

package/karma.conf.js

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../../coverage/acorex/core'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/acorex/core",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/package.json

@@ -1,40 +1,23 @@
-{
-  "name": "@acorex/core",
-  "version": "5.8.0",
-  "peerDependencies": {
-    "@angular/common": "^13.3.7",
-    "@angular/core": "^13.3.7",
-    "autoprefixer": "^10.4.0",
-    "lodash-es": "^4.17.20",
-    "postcss-import": "^14.0.2",
-    "postcss-nesting": "^10.0.3",
-    "tailwind-rtl-utilities": "^3.0.5",
-    "animated-tailwindcss": "^3.2.5",
-    "tailwindcss": "^3.0.24",
-    "tinycolor2": "^1.4.2",
-    "tinygradient": "^1.1.5"
-  },
-  "dependencies": {
-    "tslib": "^2.3.1"
-  },
-  "module": "fesm2015/acorex-core.mjs",
-  "es2020": "fesm2020/acorex-core.mjs",
-  "esm2020": "esm2020/acorex-core.mjs",
-  "fesm2020": "fesm2020/acorex-core.mjs",
-  "fesm2015": "fesm2015/acorex-core.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2020": "./esm2020/acorex-core.mjs",
-      "es2020": "./fesm2020/acorex-core.mjs",
-      "es2015": "./fesm2015/acorex-core.mjs",
-      "node": "./fesm2015/acorex-core.mjs",
-      "default": "./fesm2020/acorex-core.mjs"
-    }
-  },
-  "sideEffects": false
-}
+{
+  "name": "@acorex/core",
+  "version": "6.0.1",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "ngPackage": {},
+  "peerDependencies": {
+    "@angular/common": "^14.0.0",
+    "@angular/core": "^14.0.0",
+    "lodash-es": "^4.17.21",
+    "tinycolor2": "^1.4.2",
+    "tinygradient": "^1.1.5"
+  },
+  "peerDependenciesMeta": {
+    "tinycolor2": {
+      "optional": true
+    },
+    "tinygradient": {
+      "optional": true
+    }
+  }
+}

package/pipes/index.ts

@@ -0,0 +1 @@
+export * from './public-api'

package/pipes/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/pipes/public-api.ts

@@ -0,0 +1,2 @@
+export * from './src/safe.pipe'
+export * from './src/pipes.module'

package/pipes/src/pipes.module.ts

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

package/pipes/src/safe.pipe.ts

@@ -0,0 +1,24 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+
+@Pipe({
+	name: 'safe',
+	pure: true
+})
+export class AXSafePipe implements PipeTransform {
+
+	constructor(protected sanitizer: DomSanitizer) { }
+
+	public transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl {
+		if (value == null || value == undefined || value == '')
+			return '';
+		switch (type) {
+			case 'html': return this.sanitizer.bypassSecurityTrustHtml(value);
+			case 'style': return this.sanitizer.bypassSecurityTrustStyle(value);
+			case 'script': return this.sanitizer.bypassSecurityTrustScript(value);
+			case 'url': return this.sanitizer.bypassSecurityTrustUrl(value);
+			case 'resourceUrl': return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+			default: throw new Error(`Invalid safe type specified: ${type}`);
+		}
+	}
+}

package/platform/index.ts

@@ -0,0 +1 @@
+export * from './public-api'

package/platform/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/platform/public-api.ts

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

package/platform/src/platform.service.ts

@@ -0,0 +1,207 @@
+import { Injectable } from '@angular/core';
+import { 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: any = {
+  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/public-api.ts

@@ -0,0 +1,4 @@
+/*
+ * Public API Surface of core
+ */
+export const ACOREX_CORE = "@acorex/core";