@html-graph/html-graph 1.2.0 → 1.3.0

package/dist/main.d.ts

@@ -109,11 +109,21 @@ export declare interface Canvas {
     /**
      * provides api for accessing graph model
      */
-    readonly model: PublicGraphStore;
+    readonly graph: Graph;
     /**
-     * provides api for canvas transformation
+     * @deprecated
+     * use "graph" property instead
+     */
+    readonly model: Graph;
+    /**
+     * provides api for canvas accessing viewport state
      */
-    readonly transformation: PublicViewportTransformer;
+    readonly viewport: Viewport;
+    /**
+     * @deprecated
+     * use "viewport" property instead
+     */
+    readonly transformation: Viewport;
     /**
      * adds node to graph
      */
@@ -187,6 +197,7 @@ declare class CanvasBuilder {
     private coreOptions;
     private dragOptions;
     private transformOptions;
+    private virtualScrollOptions;
     private hasDraggableNode;
     private hasTransformableViewport;
     private hasResizeReactiveNodes;
@@ -216,6 +227,7 @@ declare class CanvasBuilder {
      * sets emitter for rendering graph inside bounded area
      */
     setBoxRenderingTrigger(trigger: EventSubject<RenderingBox>): CanvasBuilder;
+    setVirtualScroll(options: VirtualScrollOptions): CanvasBuilder;
     /**
      * builds final canvas
      */
@@ -228,8 +240,10 @@ export { CanvasBuilder as HtmlGraphBuilder }
  * @deprecated
  */
 export declare class CanvasCore implements Canvas {
-    readonly transformation: PublicViewportTransformer;
-    readonly model: PublicGraphStore;
+    readonly viewport: Viewport;
+    readonly transformation: Viewport;
+    readonly graph: Graph;
+    readonly model: Graph;
     private readonly internalTransformation;
     private readonly internalModel;
     private readonly graphStoreController;
@@ -415,6 +429,32 @@ export declare class EventSubject<T> implements EventEmitter<T>, EventHandler<T>
     emit(payload: T): void;
 }
 
+/**
+ * This entity is responsible for providing access to end user in a safe way
+ */
+declare class Graph {
+    private readonly graphStore;
+    constructor(graphStore: GraphStore);
+    getNode(nodeId: unknown): GraphNode | null;
+    getAllNodeIds(): readonly unknown[];
+    getPort(portId: unknown): GraphPort | null;
+    getAllPortIds(): readonly unknown[];
+    getNodePortIds(nodeId: unknown): readonly unknown[] | null;
+    getPortNodeId(portId: unknown): unknown | null;
+    getAllEdgeIds(): readonly unknown[];
+    getEdge(edgeId: unknown): GraphEdge | null;
+    getPortIncomingEdgeIds(portId: unknown): readonly unknown[] | null;
+    getPortOutcomingEdgeIds(portId: unknown): readonly unknown[] | null;
+    getPortCycleEdgeIds(portId: unknown): readonly unknown[] | null;
+    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[] | null;
+    getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
+    getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
+    getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[] | null;
+    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[] | null;
+}
+export { Graph }
+export { Graph as PublicGraphStore }
+
 export declare interface GraphEdge {
     readonly from: unknown;
     readonly to: unknown;
@@ -600,41 +640,6 @@ declare type Priority_2 = ConstantPriority_2 | IncrementalPriority_2 | SharedInc
 
 export declare type PriorityFn = () => number;
 
-/**
- * This entity is responsible for providing access to end user in a safe way
- */
-export declare class PublicGraphStore {
-    private readonly graphStore;
-    constructor(graphStore: GraphStore);
-    getNode(nodeId: unknown): GraphNode | null;
-    getAllNodeIds(): readonly unknown[];
-    getPort(portId: unknown): GraphPort | null;
-    getAllPortIds(): readonly unknown[];
-    getNodePortIds(nodeId: unknown): readonly unknown[] | null;
-    getPortNodeId(portId: unknown): unknown | null;
-    getAllEdgeIds(): readonly unknown[];
-    getEdge(edgeId: unknown): GraphEdge | null;
-    getPortIncomingEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortOutcomingEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortCycleEdgeIds(portId: unknown): readonly unknown[] | null;
-    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[] | null;
-    getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[] | null;
-}
-
-/**
- * This entity is responsible for providing viewport transformation state to the
- * end user in a safe way
- */
-export declare class PublicViewportTransformer {
-    private readonly transformer;
-    constructor(transformer: ViewportTransformer);
-    getViewportMatrix(): TransformState;
-    getContentMatrix(): TransformState;
-}
-
 export declare interface RenderingBox {
     readonly x: number;
     readonly y: number;
@@ -644,26 +649,29 @@ export declare interface RenderingBox {
 
 export declare class ResizeReactiveNodesCanvas implements Canvas {
     private readonly canvas;
-    readonly transformation: PublicViewportTransformer;
-    readonly model: PublicGraphStore;
+    readonly viewport: Viewport;
+    readonly transformation: Viewport;
+    readonly graph: Graph;
+    readonly model: Graph;
     private readonly nodes;
     private readonly nodeIdGenerator;
     private readonly nodesResizeObserver;
+    private readonly window;
     constructor(canvas: Canvas);
-    attach(element: HTMLElement): ResizeReactiveNodesCanvas;
-    detach(): ResizeReactiveNodesCanvas;
-    addNode(request: AddNodeRequest): ResizeReactiveNodesCanvas;
-    updateNode(nodeId: unknown, request?: UpdateNodeRequest): ResizeReactiveNodesCanvas;
-    removeNode(nodeId: unknown): ResizeReactiveNodesCanvas;
-    markPort(port: MarkPortRequest): ResizeReactiveNodesCanvas;
-    updatePort(portId: string, request?: UpdatePortRequest): ResizeReactiveNodesCanvas;
-    unmarkPort(portId: string): ResizeReactiveNodesCanvas;
-    addEdge(edge: AddEdgeRequest): ResizeReactiveNodesCanvas;
-    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): ResizeReactiveNodesCanvas;
-    removeEdge(edgeId: unknown): ResizeReactiveNodesCanvas;
-    patchViewportMatrix(request: PatchMatrixRequest): ResizeReactiveNodesCanvas;
-    patchContentMatrix(request: PatchMatrixRequest): ResizeReactiveNodesCanvas;
-    clear(): ResizeReactiveNodesCanvas;
+    attach(element: HTMLElement): Canvas;
+    detach(): Canvas;
+    addNode(request: AddNodeRequest): Canvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): Canvas;
+    removeNode(nodeId: unknown): Canvas;
+    markPort(port: MarkPortRequest): Canvas;
+    updatePort(portId: string, request?: UpdatePortRequest): Canvas;
+    unmarkPort(portId: string): Canvas;
+    addEdge(edge: AddEdgeRequest): Canvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): Canvas;
+    removeEdge(edgeId: unknown): Canvas;
+    patchViewportMatrix(request: PatchMatrixRequest): Canvas;
+    patchContentMatrix(request: PatchMatrixRequest): Canvas;
+    clear(): Canvas;
     destroy(): void;
     private handleNodeResize;
 }
@@ -751,6 +759,7 @@ export declare interface TransformOptions {
     readonly scale?: {
         readonly mouseWheelSensitivity?: number;
         readonly mouseWheelEventVerifier?: (event: WheelEvent) => boolean;
+        readonly wheelFinishTimeout?: number;
     };
     readonly shift?: {
         readonly cursor?: string | null;
@@ -819,8 +828,10 @@ export declare interface UpdatePortRequest {
 
 export declare class UserDraggableNodesCanvas implements Canvas {
     private readonly canvas;
-    readonly model: PublicGraphStore;
-    readonly transformation: PublicViewportTransformer;
+    readonly graph: Graph;
+    readonly model: Graph;
+    readonly viewport: Viewport;
+    readonly transformation: Viewport;
     private maxNodePriority;
     private readonly nodes;
     private grabbedNodeId;
@@ -834,20 +845,20 @@ export declare class UserDraggableNodesCanvas implements Canvas {
     private readonly window;
     private readonly options;
     constructor(canvas: Canvas, dragOptions?: DragOptions);
-    attach(element: HTMLElement): UserDraggableNodesCanvas;
-    detach(): UserDraggableNodesCanvas;
-    addNode(request: AddNodeRequest): UserDraggableNodesCanvas;
-    updateNode(nodeId: unknown, request?: UpdateNodeRequest): UserDraggableNodesCanvas;
-    removeNode(nodeId: unknown): UserDraggableNodesCanvas;
-    markPort(port: MarkPortRequest): UserDraggableNodesCanvas;
-    updatePort(portId: string, request?: UpdatePortRequest): UserDraggableNodesCanvas;
-    unmarkPort(portId: string): UserDraggableNodesCanvas;
-    addEdge(edge: AddEdgeRequest): UserDraggableNodesCanvas;
-    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): UserDraggableNodesCanvas;
-    removeEdge(edgeId: unknown): UserDraggableNodesCanvas;
-    patchViewportMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
-    patchContentMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
-    clear(): UserDraggableNodesCanvas;
+    attach(element: HTMLElement): Canvas;
+    detach(): Canvas;
+    addNode(request: AddNodeRequest): Canvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): Canvas;
+    removeNode(nodeId: unknown): Canvas;
+    markPort(port: MarkPortRequest): Canvas;
+    updatePort(portId: string, request?: UpdatePortRequest): Canvas;
+    unmarkPort(portId: string): Canvas;
+    addEdge(edge: AddEdgeRequest): Canvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): Canvas;
+    removeEdge(edgeId: unknown): Canvas;
+    patchViewportMatrix(request: PatchMatrixRequest): Canvas;
+    patchContentMatrix(request: PatchMatrixRequest): Canvas;
+    clear(): Canvas;
     destroy(): void;
     private dragNode;
     private updateMaxNodePriority;
@@ -860,11 +871,14 @@ export declare class UserDraggableNodesCanvas implements Canvas {
 
 declare class UserTransformableViewportCanvas implements Canvas {
     private readonly canvas;
-    readonly model: PublicGraphStore;
-    readonly transformation: PublicViewportTransformer;
+    readonly graph: Graph;
+    readonly model: Graph;
+    readonly viewport: Viewport;
+    readonly transformation: Viewport;
     private element;
     private prevTouches;
     private window;
+    private wheelFinishTimer;
     private readonly onMouseDown;
     private readonly onWindowMouseMove;
     private readonly onWindowMouseUp;
@@ -875,20 +889,20 @@ declare class UserTransformableViewportCanvas implements Canvas {
     private readonly observer;
     private readonly options;
     constructor(canvas: Canvas, transformOptions?: TransformOptions);
-    attach(element: HTMLElement): UserTransformableViewportCanvas;
-    detach(): UserTransformableViewportCanvas;
-    addNode(node: AddNodeRequest): UserTransformableViewportCanvas;
-    updateNode(nodeId: unknown, request?: UpdateNodeRequest): UserTransformableViewportCanvas;
-    removeNode(nodeId: unknown): UserTransformableViewportCanvas;
-    markPort(port: MarkPortRequest): UserTransformableViewportCanvas;
-    updatePort(portId: string, request?: UpdatePortRequest): UserTransformableViewportCanvas;
-    unmarkPort(portId: string): UserTransformableViewportCanvas;
-    addEdge(edge: AddEdgeRequest): UserTransformableViewportCanvas;
-    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): UserTransformableViewportCanvas;
-    removeEdge(edgeId: unknown): UserTransformableViewportCanvas;
-    patchViewportMatrix(request: PatchMatrixRequest): UserTransformableViewportCanvas;
-    patchContentMatrix(request: PatchMatrixRequest): UserTransformableViewportCanvas;
-    clear(): UserTransformableViewportCanvas;
+    attach(element: HTMLElement): Canvas;
+    detach(): Canvas;
+    addNode(node: AddNodeRequest): Canvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): Canvas;
+    removeNode(nodeId: unknown): Canvas;
+    markPort(port: MarkPortRequest): Canvas;
+    updatePort(portId: string, request?: UpdatePortRequest): Canvas;
+    unmarkPort(portId: string): Canvas;
+    addEdge(edge: AddEdgeRequest): Canvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): Canvas;
+    removeEdge(edgeId: unknown): Canvas;
+    patchViewportMatrix(request: PatchMatrixRequest): Canvas;
+    patchContentMatrix(request: PatchMatrixRequest): Canvas;
+    clear(): Canvas;
     destroy(): void;
     private moveViewport;
     private scaleViewport;
@@ -896,6 +910,7 @@ declare class UserTransformableViewportCanvas implements Canvas {
     private removeMouseDragListeners;
     private stopTouchDrag;
     private removeTouchDragListeners;
+    private performTransform;
 }
 export { UserTransformableViewportCanvas as UserTransformableCanvas }
 export { UserTransformableViewportCanvas }
@@ -963,6 +978,19 @@ declare interface VerticalEdgeShape_3 {
     readonly detourDirection?: number | undefined;
 }
 
+/**
+ * This entity is responsible for providing viewport transformation state to the
+ * end user in a safe way
+ */
+declare class Viewport {
+    private readonly transformer;
+    constructor(transformer: ViewportTransformer);
+    getViewportMatrix(): TransformState;
+    getContentMatrix(): TransformState;
+}
+export { Viewport as PublicViewportTransformer }
+export { Viewport }
+
 /**
  * This entity is responsible for storing viewport transformation
  */
@@ -978,4 +1006,11 @@ declare class ViewportTransformer {
     patchContentMatrix(matrix: PatchTransformRequest): void;
 }
 
+declare interface VirtualScrollOptions {
+    readonly maxNodeContainingRadius: {
+        readonly vertical: number;
+        readonly horizontal: number;
+    };
+}
+
 export { }