@stemy/ngx-utils 19.7.0 → 19.7.2

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

@@ -283,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);
@@ -301,45 +301,92 @@ export interface IPoint {
     readonly x: number;
     readonly y: number;
 }
+export interface ShapeIntersection {
+    hit: boolean;
+    pa?: IPoint;
+    pb?: IPoint;
+    point?: IPoint;
+}
+export interface ShapeDistance {
+    distance: number;
+    pa?: IPoint;
+    pb?: IPoint;
+}
 export interface IShape extends IPoint {
     readonly center: IPoint;
     support(dir: IPoint): IPoint;
-    distance(p: IPoint): number;
-    minDistance(shape: IShape): number;
+    move(pos: IPoint): IShape;
+    intersection(shape: IShape): ShapeIntersection;
+    intersects(shape: IShape): boolean;
+    minDistance(shape: IShape): ShapeDistance;
+    distance(shape: IShape): number;
 }
+export type CanvasResizeMode = "fit" | "fill";
 export type CanvasItemDirection = "horizontal" | "vertical" | "free" | "none";
 export type CanvasPaintFunc = (ctx: CanvasRenderingContext2D) => MaybePromise<GlobalCompositeOperation | null>;
+export type RangeCoords = [from: number, to: number];
+export type RectCoords = [left: number, top: number, right: number, bottom: number];
+/**
+ * Interface for an interactive canvas params
+ */
+export interface InteractiveCanvasParams {
+    xRange?: RangeCoords;
+    yRange?: RangeCoords;
+    exclusions?: ReadonlyArray<RectCoords>;
+    [key: string]: any;
+}
+/**
+ * Interface for an interactive canvas item
+ */
+export interface InteractiveCanvasItem {
+    readonly position: IPoint;
+    readonly shapes: ReadonlyArray<IShape>;
+    readonly canvas: InteractiveCanvas;
+    readonly index: number;
+    readonly active: boolean;
+    readonly isValid: boolean;
+    readonly validPosition: IPoint;
+    draw(ctx: CanvasRenderingContext2D): MaybePromise<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?: ReadonlyArray<InteractiveCanvasItem>;
+    readonly infinite?: boolean;
+    readonly resizeMode?: CanvasResizeMode;
+    readonly params?: InteractiveCanvasParams;
+    readonly realWidth?: number;
+    readonly realHeight?: number;
+    readonly $items?: Observable<InteractiveCanvasItems>;
+    readonly items?: InteractiveCanvasItems;
     readonly canvas: HTMLCanvasElement;
+    readonly lockedItem?: InteractiveCanvasItem;
+    readonly selectedItem?: InteractiveCanvasItem;
+    hoveredItem?: InteractiveCanvasItem;
+    readonly xRange?: RangeCoords;
+    readonly yRange?: RangeCoords;
     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>;
+    readonly exclusions?: ReadonlyArray<IShape>;
     rendered?: boolean;
     tempPaint(cb: CanvasPaintFunc): Promise<void>;
 }
-export interface InteractiveCanvasItem {
-    readonly position: IPoint;
-    readonly shapes: ReadonlyArray<IShape>;
-    readonly canvas: InteractiveCanvas;
-    readonly index: number;
-    readonly active: boolean;
-    readonly isValid: boolean;
-    readonly validPosition: IPoint;
-    draw(ctx: CanvasRenderingContext2D): MaybePromise<void>;
-}
-export type InteractiveDrawFn = (ctx: InteractiveCanvas) => void | Promise<void>;
+export type InteractiveCanvasRenderer = (renderCanvas: InteractiveCanvas, renderCtx: Record<string, any>) => MaybePromise<void>;
 export interface InteractivePanEvent {
-    pointers?: any[];
+    canvas: InteractiveCanvas;
+    item: InteractiveCanvasItem;
     deltaX?: number;
     deltaY?: number;
-    item?: InteractiveCanvasItem;
     [key: string]: any;
 }
 export interface InteractiveCanvasPointer {
@@ -477,6 +524,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;

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,54 +1,72 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, Renderer2 } from "@angular/core";
-import { Subscription } from "rxjs";
-import { CanvasPaintFunc, InteractiveCanvas, InteractiveCanvasItem, InteractiveCanvasPointer, InteractiveDrawFn, InteractivePanEvent } from "../../common-types";
+import { BehaviorSubject, Subscription } from "rxjs";
+import { CanvasPaintFunc, CanvasResizeMode, InteractiveCanvas, InteractiveCanvasItem, InteractiveCanvasParams, InteractiveCanvasPointer, InteractiveCanvasRenderer, InteractivePanEvent, IPoint, RangeCoords } from "../../common-types";
+import { Point, Rect } from "../../utils/geometry";
 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 {
     readonly renderer: Renderer2;
     readonly universal: UniversalService;
-    readonly element: ElementRef<HTMLElement>;
-    readonly rootElement: HTMLElement;
+    infinite: boolean;
+    resizeMode: CanvasResizeMode;
+    params: InteractiveCanvasParams;
+    /**
+     * Real life-size width of the canvas
+     */
+    realWidth: number;
+    /**
+     * Real life-size height of the canvas
+     */
+    realHeight: number;
     debug: boolean;
     horizontal: boolean;
     selectedIndex: number;
-    resizeMode: "fit" | "fill";
-    realWidth: number;
-    realHeight: number;
+    /**
+     * Relative offset of the panning. It is based on the rendered canvas height
+     */
     panOffset: number;
-    params: Record<string, any>;
-    beforeItems: InteractiveDrawFn;
-    afterItems: InteractiveDrawFn;
+    renderCtx: Record<string, any>;
+    beforeItems: ReadonlyArray<InteractiveCanvasRenderer>;
+    afterItems: ReadonlyArray<InteractiveCanvasRenderer>;
     selectedIndexChange: EventEmitter<number>;
-    itemPan: EventEmitter<InteractivePanEvent>;
-    itemPanEnd: EventEmitter<InteractivePanEvent>;
-    get items(): ReadonlyArray<InteractiveCanvasItem>;
+    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);
+    xRange: RangeCoords;
+    yRange: RangeCoords;
     ratio: number;
     styles: CSSStyleDeclaration;
     ctx: CanvasRenderingContext2D;
     canvasWidth: number;
     canvasHeight: number;
+    fullHeight: number;
+    viewRatio: number;
     rotation: number;
     basePan: number;
-    fullHeight: number;
+    cycles: number[];
+    exclusions: Rect[];
     protected tempCanvas: HTMLCanvasElement;
     protected shouldDraw: boolean;
     protected hoveredIndex: number;
-    protected itemComponents: InteractiveItemComponent[];
     protected subscription: Subscription;
     protected containerElem: ElementRef<HTMLDivElement>;
     protected canvasElem: ElementRef<HTMLCanvasElement>;
     protected itemList: QueryList<InteractiveItemComponent>;
     protected touched: boolean;
-    protected deltaX: number;
-    protected deltaY: number;
+    protected panStartRotation: number;
+    protected panStartPos: IPoint;
     protected lockedIndex: number;
-    constructor(renderer: Renderer2, universal: UniversalService, element: ElementRef<HTMLElement>, rootElement: HTMLElement);
-    ctrInit(): void;
+    constructor(renderer: Renderer2, universal: UniversalService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngOnChanges(): void;
@@ -57,22 +75,24 @@ export declare class InteractiveCanvasComponent implements InteractiveCanvas, On
     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 fixRotation(): void;
     protected fixItems(): void;
     protected selectItem(pointer: InteractiveCanvasPointer): void;
+    protected toCanvasPoint(pointer: InteractiveCanvasPointer): Point;
     protected getIndexUnderPointer(pointer: InteractiveCanvasPointer): number;
     protected updateCursor(): void;
     protected getCursor(): string;
     protected redraw(): void;
     protected drawItems(): Promise<void>;
+    protected drawItem(ctx: CanvasRenderingContext2D, item: InteractiveCanvasItem): Promise<void>;
     protected draw(): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<InteractiveCanvasComponent, 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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractiveCanvasComponent, "interactive-canvas", never, { "infinite": { "alias": "infinite"; "required": false; }; "resizeMode": { "alias": "resizeMode"; "required": false; }; "params": { "alias": "params"; "required": false; }; "realWidth": { "alias": "realWidth"; "required": false; }; "realHeight": { "alias": "realHeight"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "panOffset": { "alias": "panOffset"; "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-item.component.d.ts

@@ -4,10 +4,11 @@ import { Point } from "../../utils/geometry";
 import { MaybePromise } from "../../helper-types";
 import * as i0 from "@angular/core";
 export declare class InteractiveItemComponent implements OnChanges, InteractiveCanvasItem {
-    protected cycles: number[];
     protected pos: Point;
     protected mShapes: IShape[];
     get shapes(): ReadonlyArray<IShape>;
+    get hovered(): boolean;
+    set hovered(value: boolean);
     get x(): number;
     set x(value: number);
     get y(): number;
@@ -27,12 +28,17 @@ export declare class InteractiveItemComponent implements OnChanges, InteractiveC
     constructor();
     draw(ctx: CanvasRenderingContext2D): MaybePromise<void>;
     ngOnChanges(): void;
-    calcShapes(cycles?: number[]): void;
+    calcShapes(): void;
     hit(point: Point): boolean;
-    move(dx: number, dy: number): void;
+    moveTo(x: number, y: number): void;
+    moveBy(dx: number, dy: number): void;
+    moveX(x: number): void;
+    moveY(y: number): void;
     moveEnd(): void;
+    protected restrictPosition(x: number, y: number): IPoint;
     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>;

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

@@ -64,8 +64,8 @@ import { UnorderedListComponent } from "./components/unordered-list/unordered-li
 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 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 | {
+export declare const components: (typeof ChipsComponent | typeof CloseBtnComponent | typeof DropListComponent | typeof DynamicTableComponent | typeof InteractiveCanvasComponent | typeof PaginationMenuComponent | typeof UnorderedListComponent | typeof UploadComponent)[];
+export declare const providers: (typeof UniversalService | typeof StateService | typeof AuthGuard | typeof EventsService | typeof AclService | typeof BaseHttpClient | typeof StorageService | typeof CacheService | typeof BaseHttpService | 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 | {
     provide: import("@angular/core").InjectionToken<import("@angular/platform-browser").EventManagerPlugin[]>;
     useClass: typeof DragDropEventPlugin;
     multi: boolean;

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

@@ -1,6 +1,7 @@
 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 function drawPoint(ctx: CanvasRenderingContext2D): 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/functions.d.ts

@@ -1,12 +1,19 @@
 import { IPoint } from "../../common-types";
 export declare function dotProduct(a: IPoint, b: IPoint): number;
+export declare function tripleProduct(a: IPoint, b: IPoint, c: IPoint): IPoint;
 export declare function isPoint(v: IPoint | number): v is IPoint;
+export declare function ensurePoint(p: IPoint, fallback?: IPoint): 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 negatePt(p: IPoint): IPoint;
+export declare function normalizePt(p: IPoint): IPoint;
+export declare function addPts(a: IPoint, b: IPoint): IPoint;
+export declare function distanceSq(a: IPoint, b: IPoint): number;
+export declare function distance(a: IPoint, b: IPoint): number;
+export declare function lerpPts(a: IPoint, b: IPoint, t: number): IPoint;
+export declare function lengthOfPt(p: IPoint): number;
+export declare function multiplyPts(a: IPoint, b: IPoint | number): IPoint;
+export declare function dividePts(a: IPoint, b: IPoint | number): IPoint;
+export declare function subPts(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;

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

@@ -0,0 +1,3 @@
+import { IShape, ShapeDistance, ShapeIntersection } from "../../common-types";
+export declare function gjkDistance(A: IShape, B: IShape): ShapeDistance;
+export declare function gjkIntersection(A: IShape, B: IShape): ShapeIntersection;

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

@@ -1,2 +1,3 @@
-export { dotProduct, isPoint, perpendicular, ptAdd, ptDistance, ptLength, ptMultiply, ptSubtract, rotateDeg, rotateRad, toDegrees, toRadians } from "./functions";
+export { gjkDistance, gjkIntersection } from "./gjk";
+export { dotProduct, tripleProduct, isPoint, ensurePoint, perpendicular, negatePt, normalizePt, addPts, distanceSq, distance, lerpPts, lengthOfPt, multiplyPts, dividePts, subPts, rotateDeg, rotateRad, toDegrees, toRadians } from "./functions";
 export { Circle, Point, Rect, Oval } from "./shapes";

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

@@ -1,4 +1,4 @@
-import { IPoint, IShape } from "../../common-types";
+import { IPoint, IShape, ShapeDistance, ShapeIntersection } from "../../common-types";
 declare abstract class Shape implements IShape {
     get center(): IPoint;
     get x(): number;
@@ -6,8 +6,11 @@ declare abstract class Shape implements IShape {
     protected pt: IPoint;
     protected constructor(x: number, y: number);
     abstract support(dir: IPoint): IPoint;
-    distance(p: IPoint): number;
-    minDistance(shape: IShape): number;
+    abstract move(pos: IPoint): IShape;
+    intersection(shape: IShape): ShapeIntersection;
+    intersects(shape: IShape): boolean;
+    minDistance(shape: IShape): ShapeDistance;
+    distance(shape: IShape): number;
 }
 export declare class Point extends Shape {
     static Zero: Point;
@@ -15,11 +18,12 @@ export declare class Point extends Shape {
     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;
+    move(pos: IPoint): IShape;
+    add(p: IPoint): Point;
+    subtract(p: IPoint): Point;
+    multiply(p: IPoint | number): Point;
+    divide(p: IPoint | number): Point;
+    dot(p: IPoint): Point;
     lerp(p: Point, ratio: number): Point;
     perpendicularTo(p: Point, length: number): Point;
     circleWith(a: Point, b: Point): Circle;
@@ -33,6 +37,7 @@ export declare class Rect extends Shape {
     readonly rotation: number;
     constructor(x: number, y: number, width: number, height: number, rotation?: number);
     support(dir: IPoint): IPoint;
+    move(pos: IPoint): Rect;
 }
 export declare class Oval extends Shape {
     readonly width: number;
@@ -40,9 +45,11 @@ export declare class Oval extends Shape {
     readonly rotation: number;
     constructor(x: number, y: number, width: number, height: number, rotation?: number);
     support(dir: IPoint): IPoint;
+    move(pos: IPoint): Oval;
 }
 export declare class Circle extends Oval {
     readonly radius: number;
     constructor(x: number, y: number, radius: number, rotation?: number);
+    move(pos: IPoint): Circle;
 }
 export {};

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

@@ -1,5 +1,39 @@
+import { RangeCoords } from "../common-types";
+export declare const EPSILON = 1e-9;
+/**
+ * Normalize a range
+ * @param minOrRange
+ * @param max
+ */
+export declare function normalizeRange(minOrRange: number | RangeCoords, max?: number): RangeCoords;
+/**
+ * Clamps a value to a range
+ * @param value
+ * @param min
+ * @param max
+ */
+export declare function clamp(value: number, min: number | RangeCoords, max?: number): number;
+/**
+ * Clamps a value to a range in a way, that when it is over in one end, then it appears from the other end
+ * @param value
+ * @param min
+ * @param max
+ */
+export declare function overflow(value: number, min: number | RangeCoords, max?: number): number;
+/**
+ * Checks if a number is equal to b number with epsilon tolerance
+ * @param a
+ * @param b
+ * @param epsilon
+ */
+export declare function isEqual(a: number, b: number, epsilon?: number): boolean;
+/**
+ * Checks if a number is equal to zero with epsilon tolerance
+ * @param a
+ * @param epsilon
+ */
+export declare function isZero(a: number, epsilon?: number): boolean;
 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/package.json

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

package/public_api.d.ts

@@ -1,6 +1,6 @@
 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, 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 { 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, ShapeIntersection, ShapeDistance, IShape, CanvasResizeMode, CanvasItemDirection, CanvasPaintFunc, RangeCoords, RectCoords, InteractiveCanvasParams, InteractiveCanvasItem, InteractiveCanvasItems, InteractiveCanvas, InteractiveCanvasRenderer, 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, TableDataItems, 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";
@@ -12,12 +12,12 @@ 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 { dotProduct, isPoint, perpendicular, ptAdd, ptDistance, ptLength, ptMultiply, ptSubtract, rotateDeg, rotateRad, toDegrees, toRadians, Point, Rect, Oval, Circle } from "./ngx-utils/utils/geometry";
+export { dotProduct, tripleProduct, isPoint, ensurePoint, perpendicular, negatePt, normalizePt, addPts, distanceSq, distance, lerpPts, lengthOfPt, multiplyPts, dividePts, subPts, rotateDeg, rotateRad, toDegrees, toRadians, gjkDistance, gjkIntersection, 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 { EPSILON, normalizeRange, clamp, overflow, MathUtils } from "./ngx-utils/utils/math.utils";
 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";

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

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