@acorex/core 7.0.19 → 7.0.20

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

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

package/http/src/{http-events.interceptor.d.ts → 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/http/src/{http-request.class.d.ts → 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/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({ providedIn: 'root' })
+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/image/index.ts

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

package/image/ng-package.json

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

package/image/public-api.ts

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

package/image/src/image.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class AXImageService {
+    constructor() { }
+
+
+    async resize(options: { maxSize: number, source: HTMLImageElement | File, type?: 'image/png' | 'image/jpeg' | 'image/webp', quality?: number }): Promise<Blob> {
+        options = Object.assign({ type: 'image/png', quality: 1 }, options);
+
+        let image: HTMLImageElement;
+        if (options.source instanceof File) {
+            var a = new Image()
+            a.src = URL.createObjectURL(options.source);
+            await new Promise<Event>((res) => a.onload = res);
+            image = a;
+        }
+        else {
+            image = options.source;
+        }
+
+        // Resize the image
+        var canvas = document.createElement('canvas'),
+            width = image.width,
+            height = image.height;
+        if (width > height) {
+            if (width > options.maxSize) {
+                height *= options.maxSize / width;
+                width = options.maxSize;
+            }
+        } else {
+            if (height > options.maxSize) {
+                width *= options.maxSize / height;
+                height = options.maxSize;
+            }
+        }
+        canvas.width = width;
+        canvas.height = height;
+        canvas.getContext('2d').drawImage(image, 0, 0, width, height);
+        return new Promise((resolve) => canvas.toBlob(resolve, options.type, options.quality));
+    }
+}

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,115 +1,16 @@
-{
-  "name": "@acorex/core",
-  "version": "7.0.19",
-  "dependencies": {
-    "tslib": "^2.3.0"
-  },
-  "peerDependencies": {
-    "@angular/common": "^15.0.4",
-    "@angular/core": "^15.0.4",
-    "lodash-es": "^4.17.21",
-    "tinycolor2": "^1.4.2",
-    "tinygradient": "^1.1.5"
-  },
-  "peerDependenciesMeta": {},
-  "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"
-    },
-    "./config": {
-      "types": "./config/index.d.ts",
-      "esm2020": "./esm2020/config/acorex-core-config.mjs",
-      "es2020": "./fesm2020/acorex-core-config.mjs",
-      "es2015": "./fesm2015/acorex-core-config.mjs",
-      "node": "./fesm2015/acorex-core-config.mjs",
-      "default": "./fesm2020/acorex-core-config.mjs"
-    },
-    "./dateTime": {
-      "types": "./dateTime/index.d.ts",
-      "esm2020": "./esm2020/dateTime/acorex-core-dateTime.mjs",
-      "es2020": "./fesm2020/acorex-core-dateTime.mjs",
-      "es2015": "./fesm2015/acorex-core-dateTime.mjs",
-      "node": "./fesm2015/acorex-core-dateTime.mjs",
-      "default": "./fesm2020/acorex-core-dateTime.mjs"
-    },
-    "./events": {
-      "types": "./events/index.d.ts",
-      "esm2020": "./esm2020/events/acorex-core-events.mjs",
-      "es2020": "./fesm2020/acorex-core-events.mjs",
-      "es2015": "./fesm2015/acorex-core-events.mjs",
-      "node": "./fesm2015/acorex-core-events.mjs",
-      "default": "./fesm2020/acorex-core-events.mjs"
-    },
-    "./file": {
-      "types": "./file/index.d.ts",
-      "esm2020": "./esm2020/file/acorex-core-file.mjs",
-      "es2020": "./fesm2020/acorex-core-file.mjs",
-      "es2015": "./fesm2015/acorex-core-file.mjs",
-      "node": "./fesm2015/acorex-core-file.mjs",
-      "default": "./fesm2020/acorex-core-file.mjs"
-    },
-    "./http": {
-      "types": "./http/index.d.ts",
-      "esm2020": "./esm2020/http/acorex-core-http.mjs",
-      "es2020": "./fesm2020/acorex-core-http.mjs",
-      "es2015": "./fesm2015/acorex-core-http.mjs",
-      "node": "./fesm2015/acorex-core-http.mjs",
-      "default": "./fesm2020/acorex-core-http.mjs"
-    },
-    "./image": {
-      "types": "./image/index.d.ts",
-      "esm2020": "./esm2020/image/acorex-core-image.mjs",
-      "es2020": "./fesm2020/acorex-core-image.mjs",
-      "es2015": "./fesm2015/acorex-core-image.mjs",
-      "node": "./fesm2015/acorex-core-image.mjs",
-      "default": "./fesm2020/acorex-core-image.mjs"
-    },
-    "./pipes": {
-      "types": "./pipes/index.d.ts",
-      "esm2020": "./esm2020/pipes/acorex-core-pipes.mjs",
-      "es2020": "./fesm2020/acorex-core-pipes.mjs",
-      "es2015": "./fesm2015/acorex-core-pipes.mjs",
-      "node": "./fesm2015/acorex-core-pipes.mjs",
-      "default": "./fesm2020/acorex-core-pipes.mjs"
-    },
-    "./platform": {
-      "types": "./platform/index.d.ts",
-      "esm2020": "./esm2020/platform/acorex-core-platform.mjs",
-      "es2020": "./fesm2020/acorex-core-platform.mjs",
-      "es2015": "./fesm2015/acorex-core-platform.mjs",
-      "node": "./fesm2015/acorex-core-platform.mjs",
-      "default": "./fesm2020/acorex-core-platform.mjs"
-    },
-    "./translation": {
-      "types": "./translation/index.d.ts",
-      "esm2020": "./esm2020/translation/acorex-core-translation.mjs",
-      "es2020": "./fesm2020/acorex-core-translation.mjs",
-      "es2015": "./fesm2015/acorex-core-translation.mjs",
-      "node": "./fesm2015/acorex-core-translation.mjs",
-      "default": "./fesm2020/acorex-core-translation.mjs"
-    },
-    "./utils": {
-      "types": "./utils/index.d.ts",
-      "esm2020": "./esm2020/utils/acorex-core-utils.mjs",
-      "es2020": "./fesm2020/acorex-core-utils.mjs",
-      "es2015": "./fesm2015/acorex-core-utils.mjs",
-      "node": "./fesm2015/acorex-core-utils.mjs",
-      "default": "./fesm2020/acorex-core-utils.mjs"
-    }
-  },
-  "sideEffects": false
-}
+{
+  "name": "@acorex/core",
+  "version": "7.0.20",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "ngPackage": {},
+  "peerDependencies": {
+    "@angular/common": "^15.0.4",
+    "@angular/core": "^15.0.4",
+    "lodash-es": "^4.17.21",
+    "tinycolor2": "^1.4.2",
+    "tinygradient": "^1.1.5"
+  },
+  "peerDependenciesMeta": {}
+}

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';