@stemy/ngx-utils 19.6.12 → 19.7.1

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;
@@ -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;
@@ -309,9 +283,9 @@ export interface IPaginationData {
 }
 export type PaginationDataLoader = (page: number, itemsPerPage: number) => Promise<IPaginationData>;
 export declare class PaginationItemContext {
-    item: any;
-    parallelItem: any;
-    count: number;
+    readonly item: any;
+    readonly parallelItem: any;
+    readonly count: number;
     index: number;
     dataIndex: number;
     constructor(item: any, parallelItem: any, count: number, index: number, dataIndex: number);
@@ -328,31 +302,59 @@ 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 interface InteractiveCanvas {
-    readonly canvasWidth: number;
-    readonly canvasHeight: number;
-    readonly ratio: number;
-    readonly fullHeight: number;
-    readonly ctx: CanvasRenderingContext2D;
-}
+export type CanvasPaintFunc = (ctx: CanvasRenderingContext2D) => MaybePromise<GlobalCompositeOperation | null>;
+/**
+ * Interface for an interactive canvas item
+ */
 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 InteractiveCanvasItems = ReadonlyArray<InteractiveCanvasItem>;
+/**
+ * Interface for an interactive canvas component
+ * Some properties are optional for compatibility with other kind of renderer functions
+ */
+export interface InteractiveCanvas {
+    readonly params?: Record<string, any>;
+    readonly $items?: Observable<InteractiveCanvasItems>;
+    readonly items?: InteractiveCanvasItems;
+    readonly canvas: HTMLCanvasElement;
+    readonly lockedItem?: InteractiveCanvasItem;
+    readonly selectedItem?: InteractiveCanvasItem;
+    hoveredItem?: InteractiveCanvasItem;
+    readonly ratio: number;
+    readonly styles: CSSStyleDeclaration;
+    readonly ctx: CanvasRenderingContext2D;
+    readonly canvasWidth: number;
+    readonly canvasHeight: number;
+    readonly fullHeight: number;
+    readonly viewRatio: number;
+    readonly rotation: number;
+    readonly basePan: number;
+    readonly cycles?: ReadonlyArray<number>;
+    rendered?: boolean;
+    tempPaint(cb: CanvasPaintFunc): Promise<void>;
+}
+export type InteractiveCanvasRenderer = (renderCanvas: InteractiveCanvas, renderCtx: Record<string, any>) => MaybePromise<void>;
 export interface InteractivePanEvent {
+    canvas: InteractiveCanvas;
+    item: InteractiveCanvasItem;
     pointers?: any[];
     deltaX?: number;
     deltaY?: number;
-    item?: InteractiveCanvasItem;
     [key: string]: any;
 }
 export interface InteractiveCanvasPointer {
@@ -490,6 +492,7 @@ export interface ITableTemplates {
 export interface ITableDataQuery {
     [column: string]: string | string[] | boolean;
 }
+export type TableDataItems = ReadonlyArray<any>;
 export type TableDataLoader = (page: number, rowsPerPage: number, orderBy: string, orderDescending: boolean, filter: string, query: ITableDataQuery) => Promise<IPaginationData>;
 export type DragDropEvent<K extends string = "item", T = any> = {
     [key in K]: T;
@@ -552,7 +555,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/dynamic-table/dynamic-table.component.d.ts

@@ -1,17 +1,18 @@
-import { AfterContentInit, AfterViewInit, ElementRef, OnChanges, QueryList, SimpleChanges, TemplateRef } from "@angular/core";
-import { DragEventHandler, IPaginationData, ITableColumns, ITableDataQuery, ITableTemplates, PaginationItemContext, TableColumns, TableDataLoader } from "../../common-types";
+import { AfterContentInit, AfterViewInit, ElementRef, OnChanges, OnDestroy, QueryList, SimpleChanges, TemplateRef } from "@angular/core";
+import { DragEventHandler, IPaginationData, ITableColumns, ITableDataQuery, ITableTemplates, PaginationItemContext, TableColumns, TableDataItems, TableDataLoader } from "../../common-types";
 import { DynamicTableTemplateDirective } from "../../directives/dynamic-table-template.directive";
 import { PaginationDirective } from "../../directives/pagination.directive";
 import { DropdownDirective } from "../../directives/dropdown.directive";
+import { Observable, Subscription } from "rxjs";
 import * as i0 from "@angular/core";
-export declare class DynamicTableComponent implements AfterContentInit, AfterViewInit, OnChanges {
+export declare class DynamicTableComponent implements AfterContentInit, AfterViewInit, OnChanges, OnDestroy {
     protected element: ElementRef<HTMLElement>;
     dataLoader: TableDataLoader;
-    data: any[];
+    data: TableDataItems | Observable<TableDataItems>;
     selected: any;
     page: number;
     urlParam: string;
-    parallelData: any[];
+    parallelData: TableDataItems;
     columns: TableColumns;
     /**
      * Parameter for displaying a simple filter search box
@@ -52,7 +53,10 @@ export declare class DynamicTableComponent implements AfterContentInit, AfterVie
     hasQuery: boolean;
     realColumns: ITableColumns;
     cols: string[];
+    sortable: boolean;
     get items(): any[];
+    protected localData: TableDataItems;
+    protected subscription: Subscription;
     rowTemplate: TemplateRef<any>;
     wrapperTemplate: TemplateRef<any>;
     columnsTemplate: TemplateRef<any>;
@@ -65,6 +69,7 @@ export declare class DynamicTableComponent implements AfterContentInit, AfterVie
     setProperty(name: string, value: any): void;
     ngAfterContentInit(): void;
     ngAfterViewInit(): void;
+    ngOnDestroy(): void;
     ngOnChanges(changes: SimpleChanges): void;
     onDragStart(ev: DragEvent, elem: HTMLElement, item: any): void;
     onDragEnter(ev: DragEvent, elem: HTMLElement, item: any): void;

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

@@ -1,31 +1,51 @@
 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 { BehaviorSubject, Subscription } from "rxjs";
+import { CanvasPaintFunc, InteractiveCanvas, InteractiveCanvasPointer, InteractiveCanvasRenderer, 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>;
+    renderCtx: Record<string, any>;
+    beforeItems: ReadonlyArray<InteractiveCanvasRenderer>;
+    afterItems: ReadonlyArray<InteractiveCanvasRenderer>;
     selectedIndexChange: EventEmitter<number>;
-    canvasWidth: number;
-    canvasHeight: number;
+    onRotate: EventEmitter<number>;
+    onItemPan: EventEmitter<InteractivePanEvent>;
+    onItemPanned: EventEmitter<InteractivePanEvent>;
+    onPan: EventEmitter<InteractivePanEvent>;
+    onPanned: EventEmitter<InteractivePanEvent>;
+    readonly $items: BehaviorSubject<InteractiveItemComponent[]>;
+    get items(): ReadonlyArray<InteractiveItemComponent>;
+    get canvas(): HTMLCanvasElement;
+    get lockedItem(): InteractiveItemComponent;
+    get selectedItem(): InteractiveItemComponent;
+    get hoveredItem(): InteractiveItemComponent;
+    set hoveredItem(item: 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;
+    cycles: number[];
+    fullHeight: number;
+    viewRatio: number;
+    protected tempCanvas: HTMLCanvasElement;
     protected shouldDraw: boolean;
-    protected panOffset: number;
     protected hoveredIndex: number;
-    protected items: ReadonlyArray<InteractiveItemComponent>;
     protected subscription: Subscription;
     protected containerElem: ElementRef<HTMLDivElement>;
     protected canvasElem: ElementRef<HTMLCanvasElement>;
@@ -34,29 +54,32 @@ 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;
-    onMouseDown(): void;
+    onMouseDown($event: MouseEvent): void;
     onMouseUp($event: MouseEvent): void;
     onMouseMove($event: MouseEvent): void;
     onMouseLeave(): void;
-    onPanStart($event: InteractivePanEvent): void;
-    onPan($event: InteractivePanEvent): void;
+    onPanStart(): void;
+    onPanMove($event: any): 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; }; "renderCtx": { "alias": "renderCtx"; "required": false; }; "beforeItems": { "alias": "beforeItems"; "required": false; }; "afterItems": { "alias": "afterItems"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "onRotate": "onRotate"; "onItemPan": "onItemPan"; "onItemPanned": "onItemPanned"; "onPan": "onPan"; "onPanned": "onPanned"; }, ["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,42 @@
-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 {
-    protected cycles: number[];
+export declare class InteractiveItemComponent implements OnChanges, InteractiveCanvasItem {
     protected pos: Point;
     protected mShapes: IShape[];
-    protected subscription: Subscription;
+    get shapes(): ReadonlyArray<IShape>;
+    get hovered(): boolean;
+    set hovered(value: boolean);
+    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;
+    calcShapes(): void;
     hit(point: Point): boolean;
-    calcShape(x: number, y: number): IShape;
-    draw(ctx: CanvasRenderingContext2D, scale?: number): void;
+    moveBy(dx: number, dy: number): void;
+    moveEnd(): void;
+    protected isValidByParams(): boolean;
+    protected isValidByDistance(other: InteractiveCanvasItem): boolean;
+    protected distToPixels(value: number): number;
+    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 InteractiveCanvasComponent | typeof InteractiveCircleComponent | typeof InteractiveRectComponent | typeof PaginationMenuComponent | typeof UnorderedListComponent | typeof UploadComponent)[];
-export declare const providers: (typeof UniversalService | typeof StateService | typeof AuthGuard | typeof BaseHttpClient | typeof StorageService | typeof EventsService | typeof CacheService | typeof BaseHttpService | typeof WasmService | typeof AclService | typeof StaticAuthService | typeof ConfigService | typeof BaseDialogService | typeof ErrorHandlerService | typeof FormatterService | typeof GlobalTemplateService | typeof IconService | typeof StaticLanguageService | typeof OpenApiService | typeof BaseToasterService | typeof ComponentLoaderService | typeof TranslatedUrlSerializer | typeof PromiseService | typeof SocketService | typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe | 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/math.utils.d.ts

@@ -1,5 +1,5 @@
+export declare const EPSILON = 1e-9;
 export declare class MathUtils {
-    static readonly EPSILON: number;
     static equal(a: number, b: number, epsilon?: number): boolean;
     static clamp(value: number, min: number, max: number): number;
     static round(value: number, precision?: number, divider?: number): number;

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/package.json

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