@stemy/ngx-utils 19.6.11 → 19.7.0

package/ngx-utils/common-types.d.ts

@@ -3,7 +3,7 @@ import { HttpClient, HttpHeaders } from "@angular/common/http";
 import { ActivatedRouteSnapshot, Data, LoadChildrenCallback, Route, Routes, UrlTree } from "@angular/router";
 import { Observable } from "rxjs";
 import { DurationLikeObject } from "luxon";
-import { StringKeys } from "./helper-types";
+import { MaybePromise, StringKeys } from "./helper-types";
 export type DurationUnit = StringKeys<DurationLikeObject>;
 export interface TypedFactoryProvider<T> {
     useFactory: (...args: any[]) => T;
@@ -92,7 +92,7 @@ export interface IAuthService {
 export type RouteValidator = (auth: IAuthService, route?: IRoute, next?: ActivatedRouteSnapshot) => Promise<boolean>;
 export interface IRouteData extends Data {
     returnState?: string[];
-    guards?: Array<ResolveFactory | RouteValidator>;
+    guards?: Array<ResolveFactory<RouteValidator> | RouteValidator>;
 }
 export interface IRoute extends Route {
     data?: IRouteData;
@@ -173,32 +173,6 @@ export interface IPromiseService {
     resolve<T>(value: T | PromiseLike<T>): Promise<T>;
     reject<T>(value: T | PromiseLike<T>): Promise<T>;
 }
-export type TypedArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Float32Array | Float64Array;
-export interface IWasmExports {
-    HEAP8: Int8Array;
-    HEAP16: Int16Array;
-    HEAP32: Int32Array;
-    HEAPU8: Uint8Array;
-    HEAPU16: Uint16Array;
-    HEAPU32: Uint32Array;
-    HEAPF32: Float32Array;
-    HEAPF64: Float64Array;
-    memory: WebAssembly.Memory;
-    [key: string]: any;
-}
-export interface IWasi {
-    instantiate(bytes: ArrayBuffer): Promise<IWasmExports>;
-}
-export interface IWasm {
-    writeArrayToMemory(array: TypedArray): Promise<number> | number;
-    readArrayFromMemory<T = TypedArray>(pointer: number, array: T): Promise<T> | T;
-    [key: string]: (...args: any[]) => any;
-}
-export interface IWasmAsync {
-    writeArrayToMemory(array: TypedArray): Promise<number>;
-    readArrayFromMemory<T = TypedArray>(pointer: number, array: T): T;
-    [key: string]: (...args: any[]) => Promise<any>;
-}
 export interface IAsyncMessage {
     message: string;
     context?: any;
@@ -328,26 +302,39 @@ export interface IPoint {
     readonly y: number;
 }
 export interface IShape extends IPoint {
-    distance(shape: IPoint): number;
+    readonly center: IPoint;
+    support(dir: IPoint): IPoint;
+    distance(p: IPoint): number;
+    minDistance(shape: IShape): number;
 }
-export type CanvasItemShape = "rect" | "circle";
 export type CanvasItemDirection = "horizontal" | "vertical" | "free" | "none";
+export type CanvasPaintFunc = (ctx: CanvasRenderingContext2D) => MaybePromise<GlobalCompositeOperation | null>;
 export interface InteractiveCanvas {
+    readonly params?: Record<string, any>;
+    readonly items?: ReadonlyArray<InteractiveCanvasItem>;
+    readonly canvas: HTMLCanvasElement;
+    readonly ratio: number;
+    readonly styles: CSSStyleDeclaration;
+    readonly ctx: CanvasRenderingContext2D;
     readonly canvasWidth: number;
     readonly canvasHeight: number;
-    readonly ratio: number;
     readonly fullHeight: number;
-    readonly ctx: CanvasRenderingContext2D;
+    readonly rotation: number;
+    readonly basePan: number;
+    rendered?: boolean;
+    tempPaint(cb: CanvasPaintFunc): Promise<void>;
 }
 export interface InteractiveCanvasItem {
     readonly position: IPoint;
-    readonly shape: CanvasItemShape;
     readonly shapes: ReadonlyArray<IShape>;
-    readonly active: boolean;
+    readonly canvas: InteractiveCanvas;
     readonly index: number;
-    draw(ctx: CanvasRenderingContext2D, scale?: number): void;
+    readonly active: boolean;
+    readonly isValid: boolean;
+    readonly validPosition: IPoint;
+    draw(ctx: CanvasRenderingContext2D): MaybePromise<void>;
 }
-export type InteractiveDrawFn = (ctx: InteractiveCanvas, items: ReadonlyArray<InteractiveCanvasItem>) => void | Promise<void>;
+export type InteractiveDrawFn = (ctx: InteractiveCanvas) => void | Promise<void>;
 export interface InteractivePanEvent {
     pointers?: any[];
     deltaX?: number;
@@ -552,7 +539,6 @@ export interface IModuleConfig {
     promiseService?: Type<IPromiseService>;
     configService?: Type<IConfigService>;
     dialogService?: Type<IDialogService>;
-    wasiImplementation?: Type<IWasi>;
     iconType?: Type<IconProps>;
     iconMap?: IconMap;
     buttonType?: Type<ButtonProps>;

package/ngx-utils/components/interactive-canvas/interactive-canvas.component.d.ts

@@ -1,31 +1,44 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, Renderer2 } from "@angular/core";
 import { Subscription } from "rxjs";
-import { InteractiveCanvas, InteractiveCanvasPointer, InteractiveDrawFn, InteractivePanEvent } from "../../common-types";
+import { CanvasPaintFunc, InteractiveCanvas, InteractiveCanvasItem, InteractiveCanvasPointer, InteractiveDrawFn, InteractivePanEvent } from "../../common-types";
 import { InteractiveItemComponent } from "./interactive-item.component";
+import { UniversalService } from "../../services/universal.service";
 import * as i0 from "@angular/core";
 export declare class InteractiveCanvasComponent implements InteractiveCanvas, OnInit, OnDestroy, AfterViewInit, OnChanges {
-    protected renderer: Renderer2;
+    readonly renderer: Renderer2;
+    readonly universal: UniversalService;
+    readonly element: ElementRef<HTMLElement>;
+    readonly rootElement: HTMLElement;
+    debug: boolean;
     horizontal: boolean;
     selectedIndex: number;
     resizeMode: "fit" | "fill";
     realWidth: number;
     realHeight: number;
-    onDraw: InteractiveDrawFn;
+    panOffset: number;
+    params: Record<string, any>;
+    beforeItems: InteractiveDrawFn;
+    afterItems: InteractiveDrawFn;
     selectedIndexChange: EventEmitter<number>;
-    canvasWidth: number;
-    canvasHeight: number;
+    itemPan: EventEmitter<InteractivePanEvent>;
+    itemPanEnd: EventEmitter<InteractivePanEvent>;
+    get items(): ReadonlyArray<InteractiveCanvasItem>;
+    get canvas(): HTMLCanvasElement;
+    get lockedItem(): InteractiveItemComponent;
+    get selectedItem(): InteractiveItemComponent;
+    get hoveredItem(): InteractiveItemComponent;
     ratio: number;
-    fullHeight: number;
+    styles: CSSStyleDeclaration;
     ctx: CanvasRenderingContext2D;
-    pan: number;
+    canvasWidth: number;
+    canvasHeight: number;
     rotation: number;
-    get selectedItem(): InteractiveItemComponent;
-    get hoveredItem(): InteractiveItemComponent;
-    get lockedItem(): InteractiveItemComponent;
+    basePan: number;
+    fullHeight: number;
+    protected tempCanvas: HTMLCanvasElement;
     protected shouldDraw: boolean;
-    protected panOffset: number;
     protected hoveredIndex: number;
-    protected items: ReadonlyArray<InteractiveItemComponent>;
+    protected itemComponents: InteractiveItemComponent[];
     protected subscription: Subscription;
     protected containerElem: ElementRef<HTMLDivElement>;
     protected canvasElem: ElementRef<HTMLCanvasElement>;
@@ -34,11 +47,13 @@ export declare class InteractiveCanvasComponent implements InteractiveCanvas, On
     protected deltaX: number;
     protected deltaY: number;
     protected lockedIndex: number;
-    constructor(renderer: Renderer2);
+    constructor(renderer: Renderer2, universal: UniversalService, element: ElementRef<HTMLElement>, rootElement: HTMLElement);
+    ctrInit(): void;
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngOnChanges(): void;
     ngAfterViewInit(): void;
+    tempPaint(cb: CanvasPaintFunc): Promise<void>;
     resize(): void;
     onTouchStart($event: TouchEvent): void;
     onTouchEnd($event: TouchEvent): void;
@@ -49,14 +64,15 @@ export declare class InteractiveCanvasComponent implements InteractiveCanvas, On
     onPanStart($event: InteractivePanEvent): void;
     onPan($event: InteractivePanEvent): void;
     onPanEnd(): void;
-    protected fixPan(): void;
+    protected fixRotation(): void;
     protected fixItems(): void;
     protected selectItem(pointer: InteractiveCanvasPointer): void;
     protected getIndexUnderPointer(pointer: InteractiveCanvasPointer): number;
     protected updateCursor(): void;
     protected getCursor(): string;
     protected redraw(): void;
+    protected drawItems(): Promise<void>;
     protected draw(): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveCanvasComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveCanvasComponent, "interactive-canvas", never, { "horizontal": { "alias": "horizontal"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "resizeMode": { "alias": "resizeMode"; "required": false; }; "realWidth": { "alias": "realWidth"; "required": false; }; "realHeight": { "alias": "realHeight"; "required": false; }; "onDraw": { "alias": "onDraw"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, ["itemList"], never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveCanvasComponent, "interactive-canvas", never, { "debug": { "alias": "debug"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "resizeMode": { "alias": "resizeMode"; "required": false; }; "realWidth": { "alias": "realWidth"; "required": false; }; "realHeight": { "alias": "realHeight"; "required": false; }; "panOffset": { "alias": "panOffset"; "required": false; }; "params": { "alias": "params"; "required": false; }; "beforeItems": { "alias": "beforeItems"; "required": false; }; "afterItems": { "alias": "afterItems"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "itemPan": "itemPan"; "itemPanEnd": "itemPanEnd"; }, ["itemList"], never, false, never>;
 }

package/ngx-utils/components/interactive-canvas/interactive-circle.component.d.ts

@@ -1,15 +1,11 @@
-import { CanvasItemShape, InteractiveCanvas, IShape } from "../../common-types";
+import { IShape } from "../../common-types";
 import { InteractiveItemComponent } from "./interactive-item.component";
-import { InteractiveCanvasComponent } from "./interactive-canvas.component";
 import * as i0 from "@angular/core";
 export declare class InteractiveCircleComponent extends InteractiveItemComponent {
-    protected iCanvas: InteractiveCanvasComponent;
     radius: number;
-    get canvas(): InteractiveCanvas;
-    get shape(): CanvasItemShape;
-    constructor(iCanvas: InteractiveCanvasComponent);
-    calcShape(x: number, y: number): IShape;
-    draw(ctx: CanvasRenderingContext2D, scale?: number): void;
+    constructor();
+    draw(ctx: CanvasRenderingContext2D): void;
+    protected calcShape(x: number, y: number): IShape;
     static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveCircleComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveCircleComponent, "interactive-circle", never, { "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
 }

package/ngx-utils/components/interactive-canvas/interactive-item.component.d.ts

@@ -1,38 +1,40 @@
-import { EventEmitter, OnChanges, OnDestroy } from "@angular/core";
-import { Subscription } from "rxjs";
-import { CanvasItemDirection, CanvasItemShape, InteractiveCanvas, InteractiveCanvasItem, InteractivePanEvent, IPoint, IShape } from "../../common-types";
+import { OnChanges } from "@angular/core";
+import { CanvasItemDirection, InteractiveCanvas, InteractiveCanvasItem, IPoint, IShape } from "../../common-types";
 import { Point } from "../../utils/geometry";
+import { MaybePromise } from "../../helper-types";
 import * as i0 from "@angular/core";
-export declare class InteractiveItemComponent implements OnDestroy, OnChanges, InteractiveCanvasItem {
+export declare class InteractiveItemComponent implements OnChanges, InteractiveCanvasItem {
     protected cycles: number[];
     protected pos: Point;
     protected mShapes: IShape[];
-    protected subscription: Subscription;
+    get shapes(): ReadonlyArray<IShape>;
+    get x(): number;
     set x(value: number);
+    get y(): number;
     set y(value: number);
+    get position(): IPoint;
     set position(value: IPoint);
-    rotation: number;
+    get isValid(): boolean;
+    get validPosition(): IPoint;
+    set validPosition(value: IPoint);
     direction: CanvasItemDirection;
     disabled: boolean;
-    onClick: EventEmitter<InteractiveCanvasItem>;
-    onPan: EventEmitter<InteractivePanEvent>;
-    onPanStart: EventEmitter<InteractivePanEvent>;
-    onPanEnd: EventEmitter<InteractivePanEvent>;
-    active: boolean;
+    canvas: InteractiveCanvas;
     index: number;
-    get shapes(): ReadonlyArray<IShape>;
-    get canvas(): InteractiveCanvas;
-    get position(): IPoint;
-    get x(): number;
-    get y(): number;
-    get shape(): CanvasItemShape;
+    active: boolean;
+    protected valid: boolean;
+    protected validPos: Point;
     constructor();
-    ngOnDestroy(): void;
+    draw(ctx: CanvasRenderingContext2D): MaybePromise<void>;
     ngOnChanges(): void;
     calcShapes(cycles?: number[]): void;
     hit(point: Point): boolean;
-    calcShape(x: number, y: number): IShape;
-    draw(ctx: CanvasRenderingContext2D, scale?: number): void;
+    move(dx: number, dy: number): void;
+    moveEnd(): void;
+    protected isValidByParams(): boolean;
+    protected isValidByDistance(other: InteractiveCanvasItem): boolean;
+    protected getMinDistance(other: InteractiveCanvasItem): number;
+    protected calcShape(x: number, y: number): IShape;
     static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveItemComponent, "__interactive-item__", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "position": { "alias": "position"; "required": false; }; "rotation": { "alias": "rotation"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onClick": "onClick"; "onPan": "onPan"; "onPanStart": "onPanStart"; "onPanEnd": "onPanEnd"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveItemComponent, "__interactive-item__", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "position": { "alias": "position"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
 }

package/ngx-utils/components/interactive-canvas/interactive-rect.component.d.ts

@@ -1,16 +1,13 @@
-import { CanvasItemShape, InteractiveCanvas, IShape } from "../../common-types";
+import { IShape } from "../../common-types";
 import { InteractiveItemComponent } from "./interactive-item.component";
-import { InteractiveCanvasComponent } from "./interactive-canvas.component";
 import * as i0 from "@angular/core";
 export declare class InteractiveRectComponent extends InteractiveItemComponent {
-    protected iCanvas: InteractiveCanvasComponent;
     width: number;
     height: number;
-    get canvas(): InteractiveCanvas;
-    get shape(): CanvasItemShape;
-    constructor(iCanvas: InteractiveCanvasComponent);
-    calcShape(x: number, y: number): IShape;
-    draw(ctx: CanvasRenderingContext2D, scale?: number): void;
+    rotation: number;
+    constructor();
+    draw(ctx: CanvasRenderingContext2D): void;
+    protected calcShape(x: number, y: number): IShape;
     static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveRectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveRectComponent, "interactive-rect", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveRectComponent, "interactive-rect", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "rotation": { "alias": "rotation"; "required": false; }; }, {}, never, never, false, never>;
 }

package/ngx-utils/ngx-utils.imports.d.ts

@@ -25,7 +25,6 @@ import { CacheService } from "./services/cache.service";
 import { ComponentLoaderService } from "./services/component-loader.service";
 import { TranslatedUrlSerializer } from "./services/translated-url.serializer";
 import { UniversalService } from "./services/universal.service";
-import { WasmService } from "./services/wasm.service";
 import { DragDropEventPlugin } from "./plugins/drag-drop-event.plugin";
 import { ResizeEventPlugin } from "./plugins/resize-event.plugin";
 import { ScrollEventPlugin } from "./plugins/scroll-event.plugin";
@@ -60,15 +59,13 @@ import { CloseBtnComponent } from "./components/close-btn/close-btn.component";
 import { DropListComponent } from "./components/drop-list/drop-list.component";
 import { DynamicTableComponent } from "./components/dynamic-table/dynamic-table.component";
 import { InteractiveCanvasComponent } from "./components/interactive-canvas/interactive-canvas.component";
-import { InteractiveCircleComponent } from "./components/interactive-canvas/interactive-circle.component";
-import { InteractiveRectComponent } from "./components/interactive-canvas/interactive-rect.component";
 import { PaginationMenuComponent } from "./components/pagination-menu/pagination-menu.component";
 import { UnorderedListComponent } from "./components/unordered-list/unordered-list.component";
 import { UploadComponent } from "./components/upload/upload.component";
 export declare const pipes: (typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe)[];
 export declare const directives: (typeof AsyncMethodBase | typeof AsyncMethodTargetDirective | typeof BackgroundDirective | typeof ComponentLoaderDirective | typeof DynamicTableTemplateDirective | typeof GlobalTemplateDirective | typeof IconDirective | typeof NgxTemplateOutletDirective | typeof PaginationDirective | typeof PaginationItemDirective | typeof ResourceIfDirective | typeof StickyDirective | typeof StickyClassDirective | typeof DropdownDirective | typeof DropdownContentDirective | typeof TabsItemDirective | typeof UnorderedListItemDirective | typeof UnorderedListTemplateDirective)[];
-export declare const components: (typeof ChipsComponent | typeof CloseBtnComponent | typeof DropListComponent | typeof DynamicTableComponent | typeof PaginationMenuComponent | typeof InteractiveCanvasComponent | typeof InteractiveCircleComponent | typeof InteractiveRectComponent | typeof UnorderedListComponent | typeof UploadComponent)[];
-export declare const providers: (typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe | typeof BaseHttpClient | typeof BaseHttpService | typeof AuthGuard | typeof AclService | typeof StaticAuthService | typeof ConfigService | typeof BaseDialogService | typeof ErrorHandlerService | typeof EventsService | typeof FormatterService | typeof GlobalTemplateService | typeof IconService | typeof StaticLanguageService | typeof OpenApiService | typeof PromiseService | typeof SocketService | typeof StateService | typeof StorageService | typeof BaseToasterService | typeof CacheService | typeof ComponentLoaderService | typeof TranslatedUrlSerializer | typeof UniversalService | typeof WasmService | typeof DeviceDetectorService | {
+export declare const components: (typeof ChipsComponent | typeof CloseBtnComponent | typeof DropListComponent | typeof DynamicTableComponent | typeof PaginationMenuComponent | typeof InteractiveCanvasComponent | typeof UnorderedListComponent | typeof UploadComponent)[];
+export declare const providers: (typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe | typeof BaseHttpClient | typeof BaseHttpService | typeof AuthGuard | typeof AclService | typeof StaticAuthService | typeof ConfigService | typeof BaseDialogService | typeof ErrorHandlerService | typeof EventsService | typeof FormatterService | typeof GlobalTemplateService | typeof IconService | typeof StaticLanguageService | typeof OpenApiService | typeof PromiseService | typeof SocketService | typeof StateService | typeof StorageService | typeof BaseToasterService | typeof CacheService | typeof ComponentLoaderService | typeof TranslatedUrlSerializer | typeof UniversalService | typeof DeviceDetectorService | {
     provide: import("@angular/core").InjectionToken<import("@angular/platform-browser").EventManagerPlugin[]>;
     useClass: typeof DragDropEventPlugin;
     multi: boolean;

package/ngx-utils/tokens.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken, Type } from "@angular/core";
 import { Request } from "express";
-import { ButtonProps, DynamicEntryComponents, DynamicModuleInfo, ErrorHandlerCallback, IApiService, IAuthService, IConfigService, IConfiguration, IconMap, IconProps, IDialogService, IIconService, ILanguageService, IPromiseService, IToasterService, IWasi, OpenApiSchemas, ResizeEventStrategy } from "./common-types";
+import { ButtonProps, DynamicEntryComponents, DynamicModuleInfo, ErrorHandlerCallback, IApiService, IAuthService, IConfigService, IConfiguration, IconMap, IconProps, IDialogService, IIconService, ILanguageService, IPromiseService, IToasterService, OpenApiSchemas, ResizeEventStrategy } from "./common-types";
 export declare const ICON_TYPE: InjectionToken<Type<IconProps>>;
 export declare const ICON_MAP: InjectionToken<IconMap>;
 export declare const BUTTON_TYPE: InjectionToken<Type<ButtonProps>>;
@@ -12,7 +12,6 @@ export declare const TOASTER_SERVICE: InjectionToken<IToasterService>;
 export declare const DIALOG_SERVICE: InjectionToken<IDialogService<any>>;
 export declare const SOCKET_IO_PATH: InjectionToken<string>;
 export declare const PROMISE_SERVICE: InjectionToken<IPromiseService>;
-export declare const WASI_IMPLEMENTATION: InjectionToken<Type<IWasi>>;
 export declare const EXPRESS_REQUEST: InjectionToken<Request>;
 export declare const API_SERVICE: InjectionToken<IApiService>;
 export declare const DYNAMIC_ENTRY_COMPONENTS: InjectionToken<DynamicEntryComponents[]>;

package/ngx-utils/utils/{canvas.utils.d.ts → canvas.d.ts}

@@ -1,4 +1,6 @@
 import { CanvasColor } from "../common-types";
+export declare function drawRect(ctx: CanvasRenderingContext2D, w: number, h: number): void;
+export declare function drawOval(ctx: CanvasRenderingContext2D, w: number, h: number): void;
 export declare class CanvasUtils {
     static manipulatePixels(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, colorTransformer: (color: CanvasColor, greyscale?: number) => CanvasColor): void;
     static thresholding(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, threshold: number, colorTransformer: (color: CanvasColor, limit: boolean, greyscale?: number) => CanvasColor): void;

package/ngx-utils/utils/geometry/distance.d.ts

@@ -0,0 +1,25 @@
+import { IPoint, IShape } from "../../common-types";
+interface SimplexLine {
+    p: IPoint;
+    a: IPoint;
+    b: IPoint;
+}
+type Simplex = SimplexLine[];
+interface ClosestPointResult {
+    simplex: Simplex;
+    closest: IPoint;
+    bary: number[];
+}
+export declare function closestPointToOrigin(simplex: Simplex): ClosestPointResult;
+/**
+ * ====== GJK distance (2D) ======
+ * We keep, for each simplex vertex, the Minkowski point p = a - b and the witnesses a,b.
+ * @param A
+ * @param B
+ */
+export declare function gjkDistance(A: IShape, B: IShape): {
+    distance: number;
+    pa: IPoint;
+    pb: IPoint;
+};
+export {};

package/ngx-utils/utils/geometry/functions.d.ts

@@ -0,0 +1,13 @@
+import { IPoint } from "../../common-types";
+export declare function dotProduct(a: IPoint, b: IPoint): number;
+export declare function isPoint(v: IPoint | number): v is IPoint;
+export declare function perpendicular(p: IPoint): IPoint;
+export declare function ptAdd(a: IPoint, b: IPoint): IPoint;
+export declare function ptDistance(a: IPoint, b: IPoint): number;
+export declare function ptLength(p: IPoint): number;
+export declare function ptMultiply(a: IPoint, b: IPoint | number): IPoint;
+export declare function ptSubtract(a: IPoint, b: IPoint): IPoint;
+export declare function rotateDeg(p: IPoint, ang: number): IPoint;
+export declare function rotateRad(p: IPoint, ang: number): IPoint;
+export declare function toDegrees(rad: number): number;
+export declare function toRadians(deg: number): number;

package/ngx-utils/utils/geometry/index.d.ts

@@ -0,0 +1,2 @@
+export { dotProduct, isPoint, perpendicular, ptAdd, ptDistance, ptLength, ptMultiply, ptSubtract, rotateDeg, rotateRad, toDegrees, toRadians } from "./functions";
+export { Circle, Point, Rect, Oval } from "./shapes";

package/ngx-utils/utils/geometry/shapes.d.ts

@@ -0,0 +1,48 @@
+import { IPoint, IShape } from "../../common-types";
+declare abstract class Shape implements IShape {
+    get center(): IPoint;
+    get x(): number;
+    get y(): number;
+    protected pt: IPoint;
+    protected constructor(x: number, y: number);
+    abstract support(dir: IPoint): IPoint;
+    distance(p: IPoint): number;
+    minDistance(shape: IShape): number;
+}
+export declare class Point extends Shape {
+    static Zero: Point;
+    get length(): number;
+    get perpendicular(): Point;
+    constructor(xOrP: number | IPoint, y?: number);
+    support(): IPoint;
+    add(p: Point): Point;
+    sub(p: Point): Point;
+    mul(p: Point | number): Point;
+    dot(p: Point): Point;
+    distance(p: IPoint): number;
+    lerp(p: Point, ratio: number): Point;
+    perpendicularTo(p: Point, length: number): Point;
+    circleWith(a: Point, b: Point): Circle;
+    tangents(c: Circle): Point[];
+    angle(p: Point): number;
+    rotateAround(p: Point, angle: number): Point;
+}
+export declare class Rect extends Shape {
+    readonly width: number;
+    readonly height: number;
+    readonly rotation: number;
+    constructor(x: number, y: number, width: number, height: number, rotation?: number);
+    support(dir: IPoint): IPoint;
+}
+export declare class Oval extends Shape {
+    readonly width: number;
+    readonly height: number;
+    readonly rotation: number;
+    constructor(x: number, y: number, width: number, height: number, rotation?: number);
+    support(dir: IPoint): IPoint;
+}
+export declare class Circle extends Oval {
+    readonly radius: number;
+    constructor(x: number, y: number, radius: number, rotation?: number);
+}
+export {};

package/ngx-utils/utils/misc.d.ts

@@ -1,5 +1,5 @@
 import { Type, ValueProvider, ɵComponentDef as ComponentDef } from "@angular/core";
-import { CssSelector, CssSelectorList } from "../common-types";
+import { CssSelector, CssSelectorList, TypedFactoryProvider } from "../common-types";
 export declare function isBrowser(): boolean;
 /**
  * Returns an elements root
@@ -20,3 +20,4 @@ export declare function getComponentDef<T>(type: Type<T>): ComponentDef<T>;
 export declare function parseSelector(selector: string | CssSelector): CssSelector;
 export declare function selectorMatchesList(list: CssSelectorList, selector: CssSelector): boolean;
 export declare function provideEntryComponents(components: Type<any>[], moduleId?: string): ValueProvider;
+export declare function provideWithOptions<O extends Object, T = any>(type: Type<T>, options: O): TypedFactoryProvider<T>;

package/ngx-utils/utils/reflect.utils.d.ts

@@ -5,5 +5,5 @@ export declare class ReflectUtils {
     static defineMetadata(key: string, data: any, target: any, name?: string): void;
     static getMetadata(key: string, target: any, name?: string): any;
     static getOwnMetadata(key: string, target: any, name?: string): any;
-    static resolve<T>(obj: ResolveFactory<T> | T, injector: Injector): T;
+    static resolve<T>(obj: T, injector: Injector): T extends ResolveFactory<infer R> ? R : T;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stemy/ngx-utils",
-  "version": "19.6.11",
+  "version": "19.7.0",
   "license": "MIT",
   "public": true,
   "repository": "https://github.com/stemyke/ngx-utils.git",

package/public_api.d.ts

@@ -1,24 +1,24 @@
 import "zone.js";
 export { MaybePromise, MaybeArray, KeysOfType, ObjOfType, StringKeys, CapitalizeFirst, CamelJoin, PrefixedPick } from "./ngx-utils/helper-types";
-export { DurationUnit, TypedFactoryProvider, TypedValueProvider, TypedExistingProvider, TypedClassProvider, TypedTokenProvider, TypedProvider, CachedFactory, ResolveFactory, IResolveFactory, CanvasColor, IIconService, ITranslation, ITranslations, ILanguageSetting, ILanguageSettings, ILanguageService, IUserData, IAuthService, RouteValidator, IRouteData, IRoute, IAclComponent, IDialogButtonConfig, IDialogConfig, IConfirmMessageConfig, IConfirmDialogConfig, IDialogService, IPromiseService, IWasi, IWasmExports, IWasm, IWasmAsync, IRouteStateInfo, NavigationUrlParam, StorageMode, ToastType, IToasterService, IAsyncMessage, AsyncMethod, IconMap, IconProps, ButtonType, ButtonSize, ButtonProps, TabValue, TabOption, ChipValue, ChipStatus, ChipOption, DropdownAttachTo, UnorderedListTemplate, UnorderedListTemplates, UnorderedListStyle, UploadType, IFileUploadResult, IFileUploadProcess, IAjaxRequestDetails, AjaxRequestCallback, ScriptType, ILoadableElement, ILoaderPromises, ISearchObservable, FactoryDependencies, ObjectType, ITimer, IExtraProperties, IGroupMap, TranslationQuery, IPageInfo, IPaginationData, PaginationDataLoader, PaginationItemContext, IPoint, IShape, CanvasItemShape, CanvasItemDirection, InteractiveCanvas, InteractiveCanvasItem, InteractiveDrawFn, InteractivePanEvent, InteractiveCanvasPointer, HttpRequestHeaders, HttpRequestQuery, HttpClientRequestOptions, HttpRequestOptions, UploadData, IIssueContext, IProgress, ProgressListener, CacheExpireMode, IHttpService, IApiService, DynamicSchemaRef, OpenApiSchemaProperty, OpenApiSchema, OpenApiSchemas, TableFilterType, ITableOrders, ITableColumn, ITableColumns, TableColumns, ITableTemplate, ITableTemplates, ITableDataQuery, TableDataLoader, DragDropEvent, DragEventHandler, ITableDragEvent, DynamicTableDragHandler, ResourceIfContext, CssSelector, CssSelectorList, DynamicComponentLocation, DynamicModuleInfo, DynamicEntryComponents, IConfiguration, IConfigService, ResizeEventStrategy, ErrorHandlerCallback, GlobalComponentModifier, AppInitializerFunc, IModuleConfig, ValuedPromise } from "./ngx-utils/common-types";
-export { ICON_TYPE, ICON_MAP, BUTTON_TYPE, ERROR_HANDLER, STATIC_SCHEMAS, RESIZE_STRATEGY, RESIZE_DELAY, ROOT_ELEMENT, SCRIPT_PARAMS, BASE_CONFIG, CONFIG_SERVICE, APP_BASE_URL, API_SERVICE, EXPRESS_REQUEST, WASI_IMPLEMENTATION, PROMISE_SERVICE, DIALOG_SERVICE, TOASTER_SERVICE, AUTH_SERVICE, LANGUAGE_SERVICE, ICON_SERVICE, OPTIONS_TOKEN } from "./ngx-utils/tokens";
+export { DurationUnit, TypedFactoryProvider, TypedValueProvider, TypedExistingProvider, TypedClassProvider, TypedTokenProvider, TypedProvider, CachedFactory, ResolveFactory, IResolveFactory, CanvasColor, IIconService, ITranslation, ITranslations, ILanguageSetting, ILanguageSettings, ILanguageService, IUserData, IAuthService, RouteValidator, IRouteData, IRoute, IAclComponent, IDialogButtonConfig, IDialogConfig, IConfirmMessageConfig, IConfirmDialogConfig, IDialogService, IPromiseService, IRouteStateInfo, NavigationUrlParam, StorageMode, ToastType, IToasterService, IAsyncMessage, AsyncMethod, IconMap, IconProps, ButtonType, ButtonSize, ButtonProps, TabValue, TabOption, ChipValue, ChipStatus, ChipOption, DropdownAttachTo, UnorderedListTemplate, UnorderedListTemplates, UnorderedListStyle, UploadType, IFileUploadResult, IFileUploadProcess, IAjaxRequestDetails, AjaxRequestCallback, ScriptType, ILoadableElement, ILoaderPromises, ISearchObservable, FactoryDependencies, ObjectType, ITimer, IExtraProperties, IGroupMap, TranslationQuery, IPageInfo, IPaginationData, PaginationDataLoader, PaginationItemContext, IPoint, IShape, CanvasItemDirection, CanvasPaintFunc, InteractiveCanvas, InteractiveCanvasItem, InteractiveDrawFn, InteractivePanEvent, InteractiveCanvasPointer, HttpRequestHeaders, HttpRequestQuery, HttpClientRequestOptions, HttpRequestOptions, UploadData, IIssueContext, IProgress, ProgressListener, CacheExpireMode, IHttpService, IApiService, DynamicSchemaRef, OpenApiSchemaProperty, OpenApiSchema, OpenApiSchemas, TableFilterType, ITableOrders, ITableColumn, ITableColumns, TableColumns, ITableTemplate, ITableTemplates, ITableDataQuery, TableDataLoader, DragDropEvent, DragEventHandler, ITableDragEvent, DynamicTableDragHandler, ResourceIfContext, CssSelector, CssSelectorList, DynamicComponentLocation, DynamicModuleInfo, DynamicEntryComponents, IConfiguration, IConfigService, ResizeEventStrategy, ErrorHandlerCallback, GlobalComponentModifier, AppInitializerFunc, IModuleConfig, ValuedPromise } from "./ngx-utils/common-types";
+export { ICON_TYPE, ICON_MAP, BUTTON_TYPE, ERROR_HANDLER, STATIC_SCHEMAS, RESIZE_STRATEGY, RESIZE_DELAY, ROOT_ELEMENT, SCRIPT_PARAMS, BASE_CONFIG, CONFIG_SERVICE, APP_BASE_URL, API_SERVICE, EXPRESS_REQUEST, PROMISE_SERVICE, DIALOG_SERVICE, TOASTER_SERVICE, AUTH_SERVICE, LANGUAGE_SERVICE, ICON_SERVICE, OPTIONS_TOKEN } from "./ngx-utils/tokens";
 export { AjaxRequestHandler } from "./ngx-utils/utils/ajax-request-handler";
 export { ArrayUtils } from "./ngx-utils/utils/array.utils";
 export { AuthGuard } from "./ngx-utils/utils/auth.guard";
 export { createTypedProvider, cachedFactory } from "./ngx-utils/utils/cached-factory";
-export { CanvasUtils } from "./ngx-utils/utils/canvas.utils";
+export { drawRect, drawOval, CanvasUtils } from "./ngx-utils/utils/canvas";
 export { DateUtils } from "./ngx-utils/utils/date.utils";
 export { FileUtils } from "./ngx-utils/utils/file.utils";
 export { ForbiddenZone } from "./ngx-utils/utils/forbidden-zone";
 export { GenericValue } from "./ngx-utils/utils/generic-value";
 export { FileSystemEntryOpenResult, FileSystemEntryOpenCb, FileSystemEntry } from "./ngx-utils/utils/file-system";
-export { Rect, Circle, Point } from "./ngx-utils/utils/geometry";
+export { dotProduct, isPoint, perpendicular, ptAdd, ptDistance, ptLength, ptMultiply, ptSubtract, rotateDeg, rotateRad, toDegrees, toRadians, Point, Rect, Oval, Circle } from "./ngx-utils/utils/geometry";
 export { Initializer } from "./ngx-utils/utils/initializer";
 export { JSONfn } from "./ngx-utils/utils/jsonfn";
 export { ReflectUtils } from "./ngx-utils/utils/reflect.utils";
 export { LoaderUtils } from "./ngx-utils/utils/loader.utils";
 export { MathUtils } from "./ngx-utils/utils/math.utils";
-export { isBrowser, getRoot, hashCode, switchClass, getCssVariables, checkTransitions, getComponentDef, parseSelector, selectorMatchesList, provideEntryComponents } from "./ngx-utils/utils/misc";
+export { isBrowser, getRoot, hashCode, switchClass, getCssVariables, checkTransitions, getComponentDef, parseSelector, selectorMatchesList, provideEntryComponents, provideWithOptions } from "./ngx-utils/utils/misc";
 export { ObjectUtils } from "./ngx-utils/utils/object.utils";
 export { ObservableUtils, ISubscriberInfo } from "./ngx-utils/utils/observable.utils";
 export { CancelablePromise, cancelablePromise, impatientPromise } from "./ngx-utils/utils/promise.utils";
@@ -28,10 +28,7 @@ export { computedPrevious, cssStyles, cssVariables } from "./ngx-utils/utils/sig
 export { SocketFactory, SocketData, SocketDataValue, SocketDataObj, SocketClient } from "./ngx-utils/utils/socket-client";
 export { TimerUtils } from "./ngx-utils/utils/timer.utils";
 export { UniqueUtils } from "./ngx-utils/utils/unique.utils";
-export { Vector } from "./ngx-utils/utils/vector";
-export { provideWithOptions } from "./ngx-utils/utils/with-options-provider";
 export { UniversalService } from "./ngx-utils/services/universal.service";
-export { WasmService } from "./ngx-utils/services/wasm.service";
 export { AclService } from "./ngx-utils/services/acl.service";
 export { ApiService } from "./ngx-utils/services/api.service";
 export { StaticAuthService } from "./ngx-utils/services/auth.service";

package/ngx-utils/services/wasm.service.d.ts

@@ -1,25 +0,0 @@
-import { Type } from "@angular/core";
-import { IWasi, IWasm, IWasmAsync } from "../common-types";
-import { UniversalService } from "./universal.service";
-import { LocalHttpService } from "./local-http.service";
-import { Wasi } from "../utils/wasi";
-import * as i0 from "@angular/core";
-/**
- * Use this service to load WebAssembly modules
- */
-export declare class WasmService {
-    protected universal: UniversalService;
-    protected http: LocalHttpService;
-    protected wasi: Type<Wasi>;
-    protected modules: {
-        [url: string]: Promise<any>;
-    };
-    protected workerModules: {
-        [url: string]: any;
-    };
-    constructor(universal: UniversalService, http: LocalHttpService, wasi: IWasi);
-    getModule<T = IWasm>(name: string): Promise<T>;
-    getWorkerModule<T = IWasmAsync>(name: string): T;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WasmService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WasmService>;
-}

package/ngx-utils/utils/geometry.d.ts

@@ -1,46 +0,0 @@
-import { IPoint, IShape } from "../common-types";
-export declare class Rect implements IShape {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-    readonly rotation: number;
-    get center(): Point;
-    get left(): number;
-    get right(): number;
-    get bottom(): number;
-    get top(): number;
-    constructor(x: number, y: number, width: number, height: number, rotation?: number);
-    distance(p: IPoint): number;
-}
-export declare class Circle implements IShape {
-    readonly x: number;
-    readonly y: number;
-    readonly radius: number;
-    get center(): Point;
-    get left(): Point;
-    get right(): Point;
-    get top(): Point;
-    get bottom(): Point;
-    get rect(): Rect;
-    constructor(x: number, y: number, radius: number);
-    distance(p: IPoint): number;
-}
-export declare class Point implements IShape {
-    readonly x: number;
-    readonly y: number;
-    static Zero: Point;
-    get length(): number;
-    get perpendicular(): Point;
-    constructor(x: number, y: number);
-    add(p: Point): Point;
-    subtract(p: Point): Point;
-    multiply(p: Point | number): Point;
-    distance(b: IPoint): number;
-    lerp(p: Point, ratio: number): Point;
-    perpendicularTo(p: Point, length: number): Point;
-    circleWith(a: Point, b: Point): Circle;
-    tangents(c: Circle): Point[];
-    angle(p: Point): number;
-    rotateAround(p: Point, angle: number): Point;
-}

package/ngx-utils/utils/vector.d.ts

@@ -1,23 +0,0 @@
-export declare class Vector {
-    x: number;
-    y: number;
-    z: number;
-    get negative(): Vector;
-    get length(): number;
-    get unit(): Vector;
-    get min(): number;
-    get max(): number;
-    get angles(): any;
-    constructor(x: number, y: number, z: number);
-    add(v: Vector | number): Vector;
-    subtract(v: Vector | number): Vector;
-    multiply(v: Vector | number): Vector;
-    divide(v: Vector | number): Vector;
-    equals(v: Vector): boolean;
-    dot(v: Vector): number;
-    cross(v: Vector): Vector;
-    angleTo(v: Vector): number;
-    toArray(n?: number): number[];
-    clone(): Vector;
-    init(x: number, y: number, z: number): Vector;
-}