@html-graph/html-graph 0.0.53 → 0.0.55

package/dist/main.d.ts

@@ -2,7 +2,7 @@ export declare interface AddEdgeRequest {
     id?: unknown;
     from: string;
     to: string;
-    options?: EdgeShape;
+    options?: EdgeShape_2;
     priority?: number;
 }
 
@@ -33,7 +33,7 @@ declare type BackgroundOptions = {
     readonly drawingFn: BackgroundDrawingFn;
 };
 
-export declare class BezierEdgeShape implements EdgeController {
+export declare class BezierEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly curvature;
@@ -114,11 +114,11 @@ export declare interface Canvas {
     /**
      * applies transformation for viewport
      */
-    patchViewportState(request: PatchViewportRequest): Canvas;
+    patchViewportMatrix(request: PatchMatrixRequest): Canvas;
     /**
-     * moves viewport to nodes
+     * applies transformation for content
      */
-    moveToNodes(nodeIds: readonly string[]): 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: PatchViewportRequest): CanvasCore;
-    moveToNodes(nodeIds: readonly string[]): 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;
 
@@ -212,7 +212,7 @@ export declare interface CoreOptions {
         /**
          * specifies default controller
          */
-        readonly shape?: EdgeShape;
+        readonly shape?: EdgeShape_2;
         /**
          * specifies default z-index value
          */
@@ -283,7 +283,7 @@ declare interface CustomEdgeShape {
 
 declare type CustomPriority = PriorityFn;
 
-export declare class CycleCircleEdgeShape implements EdgeController {
+export declare class CycleCircleEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -298,7 +298,7 @@ export declare class CycleCircleEdgeShape implements EdgeController {
     update(x: number, y: number, _width: number, _height: number, from: PortPayload): void;
 }
 
-export declare class CycleSquareEdgeShape implements EdgeController {
+export declare class CycleSquareEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -315,7 +315,7 @@ export declare class CycleSquareEdgeShape implements EdgeController {
     update(x: number, y: number, _width: number, _height: number, from: PortPayload): void;
 }
 
-export declare class DetourStraightEdgeShape implements EdgeController {
+export declare class DetourStraightEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -341,21 +341,21 @@ export declare interface DragOptions {
     };
 }
 
-export declare interface EdgeController {
-    readonly svg: SVGSVGElement;
-    update(x: number, y: number, width: number, height: number, from: PortPayload, to: PortPayload): void;
-}
-
 declare interface EdgePayload {
     from: string;
     to: string;
-    shape: EdgeController;
+    shape: EdgeShape;
     priority: number;
 }
 
-declare type EdgeShape = BezierEdgeShape_2 | StraightEdgeShape_2 | CustomEdgeShape | HorizontalEdgeShape_2 | VerticalEdgeShape_2;
+export declare interface EdgeShape {
+    readonly svg: SVGSVGElement;
+    update(x: number, y: number, width: number, height: number, from: PortPayload, to: PortPayload): void;
+}
 
-declare type EdgeShapeFactory = (type: EdgeType) => EdgeController;
+declare type EdgeShape_2 = BezierEdgeShape_2 | StraightEdgeShape_2 | CustomEdgeShape | HorizontalEdgeShape_2 | VerticalEdgeShape_2;
+
+declare type EdgeShapeFactory = (type: EdgeType) => EdgeShape;
 
 export declare enum EdgeType {
     Regular = "regular",
@@ -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: EdgeController, priority: number): 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[];
@@ -413,7 +417,7 @@ declare class GraphStore {
     getNodeCycleEdges(nodeId: unknown): readonly unknown[];
 }
 
-export declare class HorizontalEdgeShape implements EdgeController {
+export declare class HorizontalEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -487,10 +491,15 @@ declare interface NodePayload {
     priority: number;
 }
 
-export declare interface PatchViewportRequest {
-    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,10 +515,14 @@ export declare type PriorityFn = () => number;
 declare class PublicGraphStore {
     private readonly graphStore;
     constructor(graphStore: GraphStore);
-    getNode(nodeId: unknown): GraphNode | undefined;
-    getPort(portId: unknown): GraphPort | undefined;
-    getPortNode(portId: string): unknown | undefined;
-    getEdge(edgeId: unknown): GraphEdge | undefined;
+    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[];
     getPortIncomingEdges(portId: unknown): readonly unknown[];
@@ -523,31 +536,13 @@ declare class PublicGraphStore {
 export declare class PublicViewportTransformer {
     private readonly transformer;
     constructor(transformer: ViewportTransformer);
-    /**
-     * for given absolute coordinates returns viewport coordinates
-     * viewport coordinated represent actual coordinates on screen for given absolute coordinates
-     */
-    getViewCoords(xa: number, ya: number): [number, number];
-    /**
-     * returns viewport scale
-     * it represents scale at which entities on canvas should be scaled to fit current scale
-     */
-    getViewScale(): number;
-    /**
-     * for given viewport coordinates returns absolute coordinates
-     * absolute coordinates represent actual coordinates, which stay constant even for transformed canvas
-     */
-    getAbsCoords(xv: number, yv: number): [number, number];
-    /**
-     * returns absolute scale
-     * it represents scale at which current viewport was scaled compared to initial state
-     */
-    getAbsScale(): number;
+    getViewportMatrix(): TransformState;
+    getContentMatrix(): TransformState;
 }
 
 declare type SharedIncrementalPriority = "shared-incremental";
 
-export declare class StraightEdgeShape implements EdgeController {
+export declare class StraightEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -578,30 +573,53 @@ 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 {
+    readonly scale: number;
+    readonly dx: number;
+    readonly dy: number;
 }
 
 export declare interface UpdateEdgeRequest {
-    readonly controller?: EdgeController;
+    readonly controller?: EdgeShape;
     readonly priority?: number;
 }
 
@@ -645,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: PatchViewportRequest): UserDraggableNodesCanvas;
-    moveToNodes(nodeIds: readonly string[]): UserDraggableNodesCanvas;
+    patchViewportMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
+    patchContentMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
     clear(): UserDraggableNodesCanvas;
     attach(element: HTMLElement): UserDraggableNodesCanvas;
     detach(): UserDraggableNodesCanvas;
@@ -665,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;
@@ -679,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;
@@ -689,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: PatchViewportRequest): UserTransformableCanvas;
-    moveToNodes(nodeIds: readonly string[]): UserTransformableCanvas;
+    patchViewportMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
+    patchContentMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
     clear(): UserTransformableCanvas;
     attach(element: HTMLElement): UserTransformableCanvas;
     detach(): UserTransformableCanvas;
@@ -701,7 +718,7 @@ export declare class UserTransformableCanvas implements Canvas {
     private scaleViewport;
 }
 
-export declare class VerticalEdgeShape implements EdgeController {
+export declare class VerticalEdgeShape implements EdgeShape {
     private readonly color;
     private readonly width;
     private readonly arrowLength;
@@ -733,12 +750,13 @@ declare interface VerticalEdgeShape_2 {
 }
 
 declare class ViewportTransformer {
-    private state;
-    getViewCoords(xa: number, ya: number): [number, number];
-    getViewScale(): number;
-    getAbsCoords(xv: number, yv: number): [number, number];
-    getAbsScale(): number;
-    patchState(scale: number | null, x: number | null, y: number | null): void;
+    private viewportMatrix;
+    private contentMatrix;
+    getViewportMatrix(): TransformState;
+    getContentMatrix(): TransformState;
+    patchViewportMatrix(scale: number | null, x: number | null, y: number | null): void;
+    patchContentMatrix(scale: number | null, dx: number | null, dy: number | null): void;
+    private calculateReverseMatrix;
 }
 
 export { }