@html-graph/html-graph 1.1.1 → 1.3.0

package/dist/main.d.ts

@@ -1,7 +1,7 @@
 export declare interface AddEdgeRequest {
     readonly id?: unknown | undefined;
-    readonly from: string;
-    readonly to: string;
+    readonly from: unknown;
+    readonly to: unknown;
     readonly shape?: EdgeShape | undefined;
     readonly priority?: number | undefined;
 }
@@ -109,11 +109,21 @@ export declare interface Canvas {
     /**
      * provides api for accessing graph model
      */
-    readonly model: PublicGraphStore;
+    readonly graph: Graph;
+    /**
+     * @deprecated
+     * use "graph" property instead
+     */
+    readonly model: Graph;
     /**
-     * provides api for canvas transformation
+     * 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,18 +197,40 @@ declare class CanvasBuilder {
     private coreOptions;
     private dragOptions;
     private transformOptions;
+    private virtualScrollOptions;
     private hasDraggableNode;
     private hasTransformableViewport;
     private hasResizeReactiveNodes;
+    private boxRenderingTrigger;
+    /**
+     * specifies options for fundamental aspects of visualization
+     */
     setOptions(options: CoreOptions): CanvasBuilder;
+    /**
+     * enables nodes draggable bu user
+     */
     setUserDraggableNodes(options?: DragOptions): CanvasBuilder;
     /**
      * @deprecated
      * use setUserTransformableViewport instead
      */
     setUserTransformableCanvas(options?: TransformOptions): CanvasBuilder;
+    /**
+     * enables viewport transformable by user
+     */
     setUserTransformableViewport(options?: TransformOptions): CanvasBuilder;
+    /**
+     * enables automatic edges update on node resize
+     */
     setResizeReactiveNodes(): CanvasBuilder;
+    /**
+     * sets emitter for rendering graph inside bounded area
+     */
+    setBoxRenderingTrigger(trigger: EventSubject<RenderingBox>): CanvasBuilder;
+    setVirtualScroll(options: VirtualScrollOptions): CanvasBuilder;
+    /**
+     * builds final canvas
+     */
     build(): Canvas;
 }
 export { CanvasBuilder }
@@ -208,12 +240,14 @@ 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;
-    private readonly htmlController;
+    private readonly htmlView;
     private readonly onAfterNodeAdded;
     private readonly onAfterEdgeAdded;
     private readonly onAfterEdgeShapeUpdated;
@@ -224,7 +258,6 @@ export declare class CanvasCore implements Canvas {
     private readonly onAfterNodeUpdated;
     private readonly onBeforeEdgeRemoved;
     private readonly onBeforeNodeRemoved;
-    private readonly onAfterTransformUpdate;
     constructor(apiOptions?: CoreOptions_2);
     attach(element: HTMLElement): CanvasCore;
     detach(): CanvasCore;
@@ -380,11 +413,48 @@ declare type EdgeShapeFactory = () => EdgeShape;
 
 declare type EdgeShapeFactory_2 = () => EdgeShape;
 
+declare interface EventEmitter<T> {
+    emit(payload: T): void;
+}
+
 declare interface EventHandler<T> {
     subscribe(callback: (payload: T) => void): void;
     unsubscribe(callback: (payload: T) => void): void;
 }
 
+export declare class EventSubject<T> implements EventEmitter<T>, EventHandler<T> {
+    private readonly callbacks;
+    subscribe(callback: (payload: T) => void): void;
+    unsubscribe(callback: (payload: T) => void): void;
+    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;
@@ -570,63 +640,38 @@ 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;
+    readonly width: number;
+    readonly height: number;
 }
 
 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;
 }
@@ -714,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;
@@ -782,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;
@@ -797,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;
@@ -823,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;
@@ -838,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;
@@ -859,6 +910,7 @@ declare class UserTransformableViewportCanvas implements Canvas {
     private removeMouseDragListeners;
     private stopTouchDrag;
     private removeTouchDragListeners;
+    private performTransform;
 }
 export { UserTransformableViewportCanvas as UserTransformableCanvas }
 export { UserTransformableViewportCanvas }
@@ -926,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
  */
@@ -941,4 +1006,11 @@ declare class ViewportTransformer {
     patchContentMatrix(matrix: PatchTransformRequest): void;
 }
 
+declare interface VirtualScrollOptions {
+    readonly maxNodeContainingRadius: {
+        readonly vertical: number;
+        readonly horizontal: number;
+    };
+}
+
 export { }