@html-graph/html-graph 8.4.0 → 8.6.0

package/dist/html-graph.d.ts

@@ -153,104 +153,28 @@ declare type BezierEdgeShapeConfig = {
 } & BezierEdgeParams;
 
 export declare class Canvas {
-    /**
-     * provides api for accessing model of rendered graph
-     */
     readonly graph: Graph;
-    /**
-     * provides api for accessing viewport state
-     */
     readonly viewport: Viewport;
-    private readonly graphStore;
-    private readonly viewportStore;
-    private readonly htmlView;
-    private readonly params;
-    private readonly nodeIdGenerator;
-    private readonly portIdGenerator;
-    private readonly edgeIdGenerator;
-    private readonly onAfterNodeAdded;
-    private readonly onAfterNodeUpdated;
-    private readonly onAfterNodePriorityUpdated;
-    private readonly onBeforeNodeRemoved;
-    private readonly onAfterPortUpdated;
-    private readonly onBeforePortUnmarked;
-    private readonly onAfterEdgeAdded;
-    private readonly onAfterEdgeShapeUpdated;
-    private readonly onAfterEdgeUpdated;
-    private readonly onAfterEdgePriorityUpdated;
-    private readonly onBeforeEdgeRemoved;
-    private readonly onBeforeClear;
-    private readonly onBeforeDestroyEmitter;
+    private readonly graphController;
+    private readonly viewportController;
+    private readonly beforeDestroyEmitter;
     private destroyed;
-    /**
-     * emits event just before destruction of canvas
-     */
     readonly onBeforeDestroy: EventHandler<void>;
-    constructor(
-    /**
-     * provides api for accessing model of rendered graph
-     */
-    graph: Graph, 
-    /**
-     * provides api for accessing viewport state
-     */
-    viewport: Viewport, graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, params: CanvasParams);
-    /**
-     * adds new node
-     */
+    constructor(graph: Graph, viewport: Viewport, graphController: GraphController, viewportController: ViewportController);
     addNode(request: AddNodeRequest): Canvas;
-    /**
-     * updates node parameters
-     */
-    updateNode(nodeId: Identifier, request?: UpdateNodeRequest): Canvas;
-    /**
-     * removes specified node
-     * all the ports of node get unmarked
-     * all the edges adjacent to node get removed
-     */
+    updateNode(nodeId: Identifier, request?: UpdateNodeRequest | undefined): Canvas;
     removeNode(nodeId: Identifier): Canvas;
-    /**
-     * marks specified element as a port for specified node
-     */
     markPort(request: MarkPortRequest): Canvas;
-    /**
-     * updates port and edges attached to it
-     */
-    updatePort(portId: Identifier, request?: UpdatePortRequest): Canvas;
-    /**
-     * unmarks specified port
-     * all the edges adjacent to the port get removed
-     */
+    updatePort(portId: Identifier, request?: UpdatePortRequest | undefined): Canvas;
     unmarkPort(portId: Identifier): Canvas;
-    /**
-     * adds new edge
-     */
     addEdge(request: AddEdgeRequest): Canvas;
-    /**
-     * updates specified edge
-     */
-    updateEdge(edgeId: Identifier, request?: UpdateEdgeRequest): Canvas;
-    /**
-     * removes specified edge
-     */
+    updateEdge(edgeId: Identifier, request?: UpdateEdgeRequest | undefined): Canvas;
     removeEdge(edgeId: Identifier): Canvas;
-    /**
-     * clears canvas from nodes and edges
-     * canvas gets rolled back to initial state and can be reused
-     */
     clear(): Canvas;
-    /**
-     * applies transformation for viewport matrix
-     */
+    focus(config?: FocusConfig | undefined): Canvas;
+    center(target: Point, config?: CenterConfig | undefined): Canvas;
     patchViewportMatrix(request: PatchMatrixRequest): Canvas;
-    /**
-     * applies transformation for content matrix
-     */
     patchContentMatrix(request: PatchMatrixRequest): Canvas;
-    /**
-     * destroys canvas
-     * canvas element gets rolled back to initial state, and can not be reused
-     */
     destroy(): void;
 }
 
@@ -282,50 +206,16 @@ export declare class CanvasBuilder {
     private readonly window;
     private readonly animationStaticNodes;
     constructor(element: HTMLElement);
-    /**
-     * specifies default values for graph entities
-     */
     setDefaults(defaults: CanvasDefaults): CanvasBuilder;
-    /**
-     * enables nodes draggable by user
-     */
     enableUserDraggableNodes(config?: DraggableNodesConfig): CanvasBuilder;
-    /**
-     * enables viewport transformable by user
-     */
     enableUserTransformableViewport(config?: ViewportTransformConfig): CanvasBuilder;
-    /**
-     * enables automatic edges update on node resize
-     */
     enableNodeResizeReactiveEdges(): CanvasBuilder;
-    /**
-     * enables built-in virtual scroll behavior, when only nodes and edges close
-     * to viewport are rendered
-     */
     enableVirtualScroll(config: VirtualScrollConfig): CanvasBuilder;
-    /**
-     * enables built-in background rendering
-     */
     enableBackground(config?: BackgroundConfig): CanvasBuilder;
-    /**
-     * enables edge creation by dragging one port to another
-     */
     enableUserConnectablePorts(config?: ConnectablePortsConfig): CanvasBuilder;
-    /**
-     * enables edges dragging by dragging one of the adjacent ports
-     */
     enableUserDraggableEdges(config?: DraggableEdgesConfig): CanvasBuilder;
-    /**
-     * enables nodes positioning with specified layout
-     */
     enableLayout(config?: LayoutConfig): CanvasBuilder;
-    /**
-     * enables animated nodes positioning with specified layout
-     */
     enableAnimatedLayout(config?: AnimatedLayoutConfig): CanvasBuilder;
-    /**
-     * builds final canvas
-     */
     build(): Canvas;
     private createHtmlView;
 }
@@ -371,24 +261,18 @@ export declare interface CanvasDefaults {
          */
         readonly priority?: Priority;
     };
+    readonly focus?: {
+        readonly contentOffset?: number;
+        readonly minContentScale?: number;
+    };
 }
 
 export declare class CanvasError extends Error {
     readonly name = "CanvasError";
 }
 
-declare interface CanvasParams {
-    readonly nodes: {
-        readonly centerFn: CenterFn;
-        readonly priorityFn: PriorityFn;
-    };
-    readonly ports: {
-        readonly direction: number;
-    };
-    readonly edges: {
-        readonly shapeFactory: EdgeShapeFactory;
-        readonly priorityFn: PriorityFn;
-    };
+export declare interface CenterConfig {
+    readonly contentScale?: number | undefined;
 }
 
 export declare type CenterFn = (width: number, height: number) => Point;
@@ -422,6 +306,10 @@ export declare type ConnectionTypeResolver = (portId: Identifier) => "direct" |
 
 declare type ConstantPriority = number;
 
+export declare type CoordsTransformConfig = CoordsTransformFn | TransformDeclaration | readonly TransformDeclaration[];
+
+export declare type CoordsTransformFn = (point: Point) => Point;
+
 declare type CustomPriority = PriorityFn;
 
 export declare interface Dimensions {
@@ -543,6 +431,12 @@ export declare class EventSubject<T> implements EventEmitter<T>, EventHandler<T>
     emit(payload: T): void;
 }
 
+export declare type FocusConfig = {
+    readonly contentOffset?: number | undefined;
+    readonly nodes?: Iterable<Identifier> | undefined;
+    readonly minContentScale?: number | undefined;
+} | Iterable<Identifier>;
+
 export declare class Graph {
     private readonly graphStore;
     readonly onAfterNodeAdded: EventHandler<Identifier>;
@@ -581,6 +475,53 @@ export declare class Graph {
     getNodeAdjacentEdgeIds(nodeId: Identifier): readonly Identifier[];
 }
 
+declare class GraphController {
+    private readonly graphStore;
+    private readonly htmlView;
+    private readonly params;
+    private readonly nodeIdGenerator;
+    private readonly portIdGenerator;
+    private readonly edgeIdGenerator;
+    private readonly onAfterNodeAdded;
+    private readonly onAfterNodeUpdated;
+    private readonly onAfterNodePriorityUpdated;
+    private readonly onBeforeNodeRemoved;
+    private readonly onAfterPortUpdated;
+    private readonly onBeforePortUnmarked;
+    private readonly onAfterEdgeAdded;
+    private readonly onAfterEdgeShapeUpdated;
+    private readonly onAfterEdgeUpdated;
+    private readonly onAfterEdgePriorityUpdated;
+    private readonly onBeforeEdgeRemoved;
+    private readonly onBeforeClear;
+    constructor(graphStore: GraphStore, htmlView: HtmlView, params: GraphControllerParams);
+    addNode(request: AddNodeRequest): void;
+    updateNode(nodeId: Identifier, request?: UpdateNodeRequest | undefined): void;
+    removeNode(nodeId: Identifier): void;
+    markPort(request: MarkPortRequest): void;
+    updatePort(portId: Identifier, request?: UpdatePortRequest | undefined): void;
+    unmarkPort(portId: Identifier): void;
+    addEdge(request: AddEdgeRequest): void;
+    updateEdge(edgeId: Identifier, request?: UpdateEdgeRequest | undefined): void;
+    removeEdge(edgeId: Identifier): void;
+    clear(): void;
+    destroy(): void;
+}
+
+declare interface GraphControllerParams {
+    readonly nodes: {
+        readonly centerFn: CenterFn;
+        readonly priorityFn: PriorityFn;
+    };
+    readonly ports: {
+        readonly direction: number;
+    };
+    readonly edges: {
+        readonly shapeFactory: EdgeShapeFactory;
+        readonly priorityFn: PriorityFn;
+    };
+}
+
 export declare interface GraphEdge {
     readonly from: Identifier;
     readonly to: Identifier;
@@ -608,7 +549,7 @@ declare class GraphStore {
     private readonly edges;
     private readonly nodesElementsMap;
     private readonly portIncomingEdges;
-    private readonly portOutcomingEdges;
+    private readonly portOutgoingEdges;
     private readonly portCycleEdges;
     private readonly elementPorts;
     private readonly afterNodeAddedEmitter;
@@ -761,25 +702,26 @@ declare type LayoutAlgorithmConfig = {
     readonly type: "custom";
     readonly instance: LayoutAlgorithm;
 } | {
-    readonly type: "forceDirected";
-    readonly dtSec?: number;
-    readonly maxIterations?: number;
-    readonly seed?: string;
-    readonly nodeCharge?: number;
-    readonly nodeMass?: number;
-    readonly edgeEquilibriumLength?: number;
-    readonly edgeStiffness?: number;
-    readonly convergenceVelocity?: number;
-    readonly maxForce?: number;
-    readonly nodeForceCoefficient?: number;
+    readonly type?: "forceDirected";
+    readonly dtSec?: number | undefined;
+    readonly maxIterations?: number | undefined;
+    readonly seed?: string | undefined;
+    readonly nodeCharge?: number | undefined;
+    readonly nodeMass?: number | undefined;
+    readonly edgeEquilibriumLength?: number | undefined;
+    readonly edgeStiffness?: number | undefined;
+    readonly convergenceVelocity?: number | undefined;
+    readonly maxForce?: number | undefined;
+    readonly nodeForceCoefficient?: number | undefined;
     readonly barnesHut?: {
-        readonly theta?: number;
-        readonly areaRadiusThreshold?: number;
-    };
+        readonly theta?: number | undefined;
+        readonly areaRadiusThreshold?: number | undefined;
+    } | undefined;
 } | {
     readonly type: "hierarchical";
-    readonly layerWidth?: number;
-    readonly layerSpace?: number;
+    readonly layerWidth?: number | undefined;
+    readonly layerSpace?: number | undefined;
+    readonly transform?: CoordsTransformConfig | undefined;
 };
 
 export declare interface LayoutAlgorithmParams {
@@ -861,6 +803,8 @@ export declare interface ScaleLimitPreprocessorParams {
     readonly maxContentScale: number | null;
 }
 
+declare type ScheduleFn = (callback: () => void) => void;
+
 export declare interface ShiftLimitPreprocessorParams {
     readonly minX: number | null;
     readonly maxX: number | null;
@@ -951,11 +895,25 @@ export declare interface StructuredEdgeShape extends EdgeShape {
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
 }
 
-export declare interface TransformPayload {
+export declare type TransformDeclaration = {
+    readonly a?: number | undefined;
+    readonly b?: number | undefined;
+    readonly c?: number | undefined;
+    readonly d?: number | undefined;
+    readonly e?: number | undefined;
+    readonly f?: number | undefined;
+} | {
+    readonly shift: Point;
+} | {
     readonly scale: number;
-    readonly x: number;
-    readonly y: number;
-}
+    readonly origin?: Point;
+} | {
+    readonly rotate: number;
+    readonly origin?: Point;
+} | {
+    readonly mirror: number;
+    readonly origin?: Point;
+};
 
 declare type TransformPreprocessorConfig = {
     readonly type: "scale-limit";
@@ -969,11 +927,11 @@ declare type TransformPreprocessorConfig = {
     readonly maxY?: number;
 } | TransformPreprocessorFn;
 
-export declare type TransformPreprocessorFn = (params: TransformPreprocessorParams) => TransformPayload;
+export declare type TransformPreprocessorFn = (params: TransformPreprocessorParams) => TransformState;
 
 export declare interface TransformPreprocessorParams {
-    readonly prevTransform: TransformPayload;
-    readonly nextTransform: TransformPayload;
+    readonly prevTransform: TransformState;
+    readonly nextTransform: TransformState;
     readonly canvasWidth: number;
     readonly canvasHeight: number;
 }
@@ -983,6 +941,8 @@ declare interface TransformState {
     readonly x: number;
     readonly y: number;
 }
+export { TransformState as TransformPayload }
+export { TransformState }
 
 export declare interface UpdateEdgeRequest {
     readonly from?: Identifier | undefined;
@@ -1072,6 +1032,27 @@ export declare class Viewport {
     createViewportCoords(contentCoords: Point): Point;
 }
 
+declare class ViewportController {
+    private readonly graphStore;
+    private readonly viewportStore;
+    private readonly params;
+    constructor(graphStore: GraphStore, viewportStore: ViewportStore, params: ViewportControllerParams);
+    patchViewportMatrix(request: PatchMatrixRequest): void;
+    patchContentMatrix(request: PatchMatrixRequest): void;
+    center(target: Point, config?: CenterConfig | undefined): void;
+    focus(config?: FocusConfig | undefined): void;
+    destroy(): void;
+    private navigate;
+}
+
+declare interface ViewportControllerParams {
+    readonly focus: {
+        readonly contentOffset: number;
+        readonly minContentScale: number;
+        readonly schedule: ScheduleFn;
+    };
+}
+
 declare class ViewportStore {
     private readonly host;
     private viewportMatrix;