@html-graph/html-graph 0.0.54 → 0.0.55

package/dist/main.d.ts

@@ -114,11 +114,11 @@ export declare interface Canvas {
     /**
      * applies transformation for viewport
      */
-    patchViewportState(request: PatchTransformRequest): Canvas;
+    patchViewportMatrix(request: PatchMatrixRequest): Canvas;
     /**
      * applies transformation for content
      */
-    patchContentState(request: PatchTransformRequest): Canvas;
+    patchContentMatrix(request: PatchMatrixRequest): Canvas;
     /**
      * attaches canvas to given element
      */
@@ -160,15 +160,15 @@ export declare class CanvasCore implements Canvas {
     addEdge(edge: AddEdgeRequest): CanvasCore;
     updateEdge(edgeId: unknown, request: UpdateEdgeRequest): CanvasCore;
     removeEdge(edgeId: unknown): CanvasCore;
-    patchViewportState(request: PatchTransformRequest): CanvasCore;
-    patchContentState(request: PatchTransformRequest): CanvasCore;
+    patchViewportMatrix(request: PatchMatrixRequest): CanvasCore;
+    patchContentMatrix(request: PatchMatrixRequest): CanvasCore;
     clear(): CanvasCore;
     attach(element: HTMLElement): CanvasCore;
     detach(): CanvasCore;
     destroy(): void;
 }
 
-export declare type CenterFn = (width: number, height: number) => [number, number];
+export declare type CenterFn = (width: number, height: number) => Point;
 
 declare type ConstantPriority = number;
 
@@ -393,13 +393,17 @@ declare class GraphStore {
     private readonly outcommingEdges;
     private readonly cycleEdges;
     addNode(nodeId: unknown, element: HTMLElement, x: number, y: number, centerFn: CenterFn, priority: number): void;
+    getAllNodes(): readonly unknown[];
     getNode(nodeId: unknown): NodePayload | undefined;
+    getNodePorts(nodeId: unknown): readonly unknown[] | undefined;
     removeNode(nodeId: unknown): void;
     addPort(portId: unknown, element: HTMLElement, nodeId: unknown, centerFn: CenterFn, dir: number): void;
+    getAllPorts(): readonly unknown[];
     getPort(portId: unknown): PortPayload | undefined;
     getPortNode(portId: string): unknown | undefined;
     removePort(portId: string): void;
     addEdge(edgeId: unknown, fromPortId: string, toPortId: string, shape: EdgeShape, priority: number): void;
+    getAllEdges(): readonly unknown[];
     getEdge(edgeId: unknown): EdgePayload | undefined;
     removeEdge(edgeId: unknown): void;
     getPortAdjacentEdges(portId: string): readonly unknown[];
@@ -487,10 +491,15 @@ declare interface NodePayload {
     priority: number;
 }
 
-export declare interface PatchTransformRequest {
-    scale?: number;
-    x?: number;
-    y?: number;
+export declare interface PatchMatrixRequest {
+    readonly scale?: number;
+    readonly dx?: number;
+    readonly dy?: number;
+}
+
+export declare interface Point {
+    readonly x: number;
+    readonly y: number;
 }
 
 export declare interface PortPayload {
@@ -506,9 +515,13 @@ export declare type PriorityFn = () => number;
 declare class PublicGraphStore {
     private readonly graphStore;
     constructor(graphStore: GraphStore);
+    getAllNodes(): readonly unknown[];
+    getAllPorts(): readonly unknown[];
     getNode(nodeId: unknown): GraphNode | null;
+    getNodePorts(nodeId: unknown): readonly unknown[] | undefined;
     getPort(portId: unknown): GraphPort | null;
     getPortNode(portId: string): unknown | null;
+    getAllEdges(): readonly unknown[];
     getEdge(edgeId: unknown): GraphEdge | null;
     getPortAdjacentEdges(portId: string): readonly unknown[];
     getNodeAdjacentEdges(nodeId: unknown): readonly unknown[];
@@ -560,32 +573,49 @@ declare interface StraightEdgeShape_2 {
     readonly detourDirection?: number;
 }
 
+export declare type TransformFinishedFn = (transform: TransformPayload) => void;
+
 export declare interface TransformOptions {
-    scale?: {
-        enabled?: boolean;
-        min?: number;
-        max?: number;
-        wheelSensitivity?: number;
+    readonly scale?: {
+        readonly enabled?: boolean;
+        readonly wheelSensitivity?: number;
     };
-    shift?: {
-        enabled?: boolean;
+    readonly shift?: {
+        readonly enabled?: boolean;
     };
-    events?: {
-        onTransform?: (payload: TransformPayload) => void;
-        onBeforeTransform?: (payload: TransformPayload) => boolean;
+    readonly transformPreprocessor?: TransformPreprocessorOption | TransformPreprocessorOption[];
+    readonly events?: {
+        readonly onTransformFinished?: TransformFinishedFn;
     };
 }
 
 export declare interface TransformPayload {
     readonly scale: number;
-    readonly x: number;
-    readonly y: number;
+    readonly dx: number;
+    readonly dy: number;
 }
 
+export declare type TransformPreprocessorFn = (prevTransform: TransformPayload, nextTransform: TransformPayload, canvasWidth: number, canvasHeight: number) => TransformPayload;
+
+declare type TransformPreprocessorOption = {
+    readonly type: "scale-limit";
+    readonly minContentScale?: number;
+    readonly maxContentScale?: number;
+} | {
+    readonly type: "shift-limit";
+    readonly minX?: number;
+    readonly maxX?: number;
+    readonly minY?: number;
+    readonly maxY?: number;
+} | {
+    readonly type: "custom";
+    readonly preprocessorFn: TransformPreprocessorFn;
+};
+
 declare interface TransformState {
-    scale: number;
-    x: number;
-    y: number;
+    readonly scale: number;
+    readonly dx: number;
+    readonly dy: number;
 }
 
 export declare interface UpdateEdgeRequest {
@@ -633,8 +663,8 @@ export declare class UserDraggableNodesCanvas implements Canvas {
     addEdge(edge: AddEdgeRequest): UserDraggableNodesCanvas;
     updateEdge(edgeId: unknown, request: UpdateEdgeRequest): UserDraggableNodesCanvas;
     removeEdge(edgeId: unknown): UserDraggableNodesCanvas;
-    patchViewportState(request: PatchTransformRequest): UserDraggableNodesCanvas;
-    patchContentState(request: PatchTransformRequest): UserDraggableNodesCanvas;
+    patchViewportMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
+    patchContentMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
     clear(): UserDraggableNodesCanvas;
     attach(element: HTMLElement): UserDraggableNodesCanvas;
     detach(): UserDraggableNodesCanvas;
@@ -653,12 +683,10 @@ export declare class UserTransformableCanvas implements Canvas {
     private element;
     private isMoving;
     private prevTouches;
-    private onTransform;
-    private onBeforeTransform;
+    private readonly onTransformFinished;
+    private readonly transformPreprocessor;
     private readonly isScalable;
     private readonly isShiftable;
-    private readonly minViewScale;
-    private readonly maxViewScale;
     private readonly wheelSensitivity;
     private readonly onMouseDown;
     private readonly onMouseMove;
@@ -667,6 +695,7 @@ export declare class UserTransformableCanvas implements Canvas {
     private readonly onTouchStart;
     private readonly onTouchMove;
     private readonly onTouchEnd;
+    private readonly observer;
     constructor(canvas: Canvas, options?: TransformOptions | undefined);
     addNode(node: AddNodeRequest): UserTransformableCanvas;
     updateNode(nodeId: unknown, request: UpdateNodeRequest): UserTransformableCanvas;
@@ -677,8 +706,8 @@ export declare class UserTransformableCanvas implements Canvas {
     addEdge(edge: AddEdgeRequest): UserTransformableCanvas;
     updateEdge(edgeId: unknown, request: UpdateEdgeRequest): UserTransformableCanvas;
     removeEdge(edgeId: unknown): UserTransformableCanvas;
-    patchViewportState(request: PatchTransformRequest): UserTransformableCanvas;
-    patchContentState(request: PatchTransformRequest): UserTransformableCanvas;
+    patchViewportMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
+    patchContentMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
     clear(): UserTransformableCanvas;
     attach(element: HTMLElement): UserTransformableCanvas;
     detach(): UserTransformableCanvas;
@@ -725,8 +754,8 @@ declare class ViewportTransformer {
     private contentMatrix;
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
-    patchViewportState(scale: number | null, x: number | null, y: number | null): void;
-    patchContentState(scale: number | null, x: number | null, y: number | null): void;
+    patchViewportMatrix(scale: number | null, x: number | null, y: number | null): void;
+    patchContentMatrix(scale: number | null, dx: number | null, dy: number | null): void;
     private calculateReverseMatrix;
 }