@html-graph/html-graph 2.3.0 → 2.5.0

package/dist/html-graph.d.ts

@@ -97,6 +97,7 @@ declare type BezierEdgeShapeConfig = {
 } & BezierEdgeParams;
 
 export declare class Canvas {
+    readonly element: HTMLElement;
     private readonly controller;
     private readonly nodeIdGenerator;
     private readonly portIdGenerator;
@@ -110,13 +111,17 @@ export declare class Canvas {
      * provides api for accessing viewport state
      */
     readonly viewport: Viewport;
-    constructor(controller: CanvasController, options: CanvasDefaults);
+    constructor(element: HTMLElement, controller: CanvasController, options: CanvasDefaults);
     /**
+     * @deprecated
+     * use CanvasBuilder.attach instead
      * attaches canvas to given element
      * detaches element first when canvas is attached
      */
     attach(element: HTMLElement): Canvas;
     /**
+     * @deprecated
+     * attach canvas once instead, then reattach wrapper element
      * detaches canvas from element when attached
      */
     detach(): Canvas;
@@ -180,6 +185,7 @@ export declare class Canvas {
 }
 
 export declare class CanvasBuilder {
+    private element;
     private canvasDefaults;
     private dragOptions;
     private transformOptions;
@@ -188,6 +194,7 @@ export declare class CanvasBuilder {
     private hasTransformableViewport;
     private hasResizeReactiveNodes;
     private boxRenderingTrigger;
+    attach(element: HTMLElement): CanvasBuilder;
     /**
      * specifies default values for graph entities
      */
@@ -224,16 +231,22 @@ export declare class CanvasBuilder {
 declare interface CanvasController {
     readonly graph: Graph;
     readonly viewport: Viewport;
+    /**
+     * @deprecated
+     */
     attach(element: HTMLElement): void;
+    /**
+     * @deprecated
+     */
     detach(): void;
     addNode(node: AddNodeRequest_3): void;
-    updateNode(nodeId: unknown, request: UpdateNodeRequest_2): void;
+    updateNode(nodeId: unknown, request: UpdateNodeRequest_3): void;
     removeNode(nodeId: unknown): void;
     markPort(port: MarkPortRequest_2): void;
-    updatePort(portId: unknown, request: UpdatePortRequest_2): void;
+    updatePort(portId: unknown, request: UpdatePortRequest_3): void;
     unmarkPort(portId: unknown): void;
     addEdge(edge: AddEdgeRequest_3): void;
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest_2): void;
+    updateEdge(edgeId: unknown, request: UpdateEdgeRequest_3): void;
     removeEdge(edgeId: unknown): void;
     patchViewportMatrix(request: PatchMatrixRequest_2): void;
     patchContentMatrix(request: PatchMatrixRequest_2): void;
@@ -355,14 +368,39 @@ export declare class EventSubject<T> implements EventEmitter<T>, EventHandler<T>
 export declare class Graph {
     private readonly graphStore;
     readonly onAfterNodeAdded: EventHandler<unknown>;
+    /**
+     * @deprecated
+     * use onAfterNodeUpdated instead
+     */
     readonly onAfterNodeCoordinatesUpdated: EventHandler<unknown>;
+    readonly onAfterNodeUpdated: EventHandler<unknown>;
     readonly onAfterNodePriorityUpdated: EventHandler<unknown>;
     readonly onBeforeNodeRemoved: EventHandler<unknown>;
+    readonly onAfterPortMarked: EventHandler<unknown>;
+    /**
+     * @deprecated
+     * use onAfterPortMarked instead
+     */
     readonly onAfterPortAdded: EventHandler<unknown>;
+    readonly onAfterPortUpdated: EventHandler<unknown>;
+    /**
+     * @deprecated
+     * use onAfterPortUpdated instead
+     */
     readonly onAfterPortDirectionUpdated: EventHandler<unknown>;
+    readonly onBeforePortUnmarked: EventHandler<unknown>;
+    /**
+     * @deprecated
+     * use onBeforePortUnmarked instead
+     */
     readonly onBeforePortRemoved: EventHandler<unknown>;
     readonly onAfterEdgeAdded: EventHandler<unknown>;
     readonly onAfterEdgeShapeUpdated: EventHandler<unknown>;
+    readonly onAfterEdgeUpdated: EventHandler<unknown>;
+    /**
+     * @deprecated
+     * use onAfterEdgeUpdated instead
+     */
     readonly onAfterEdgeAdjacentPortsUpdated: EventHandler<unknown>;
     readonly onAfterEdgePriorityUpdated: EventHandler<unknown>;
     readonly onBeforeEdgeRemoved: EventHandler<unknown>;
@@ -420,49 +458,46 @@ declare class GraphStore {
     private readonly incommingEdges;
     private readonly outcommingEdges;
     private readonly cycleEdges;
-    private readonly onAfterNodeAddedEmitter;
+    private readonly afterNodeAddedEmitter;
     readonly onAfterNodeAdded: EventHandler<unknown>;
-    private readonly onAfterNodeCoordinatesUpdatedEmitter;
-    readonly onAfterNodeCoordinatesUpdated: EventHandler<unknown>;
-    private readonly onAfterNodePriorityUpdatedEmitter;
+    private readonly afterNodeUpdatedEmitter;
+    readonly onAfterNodeUpdated: EventHandler<unknown>;
+    private readonly afterNodePriorityUpdatedEmitter;
     readonly onAfterNodePriorityUpdated: EventHandler<unknown>;
-    private readonly onBeforeNodeRemovedEmitter;
+    private readonly beforeNodeRemovedEmitter;
     readonly onBeforeNodeRemoved: EventHandler<unknown>;
-    private readonly onAfterPortAddedEmitter;
+    private readonly afterPortAddedEmitter;
     readonly onAfterPortAdded: EventHandler<unknown>;
-    private readonly onAfterPortDirectionUpdatedEmitter;
-    readonly onAfterPortDirectionUpdated: EventHandler<unknown>;
-    private readonly onBeforePortRemovedEmitter;
+    private readonly afterPortUpdatedEmitter;
+    readonly onAfterPortUpdated: EventHandler<unknown>;
+    private readonly beforePortRemovedEmitter;
     readonly onBeforePortRemoved: EventHandler<unknown>;
-    private readonly onAfterEdgeAddedEmitter;
+    private readonly afterEdgeAddedEmitter;
     readonly onAfterEdgeAdded: EventHandler<unknown>;
-    private readonly onAfterEdgeShapeUpdatedEmitter;
+    private readonly afterEdgeShapeUpdatedEmitter;
     readonly onAfterEdgeShapeUpdated: EventHandler<unknown>;
-    private readonly onAfterEdgeAdjacentPortsUpdatedEmitter;
-    readonly onAfterEdgeAdjacentPortsUpdated: EventHandler<unknown>;
-    private readonly onAfterEdgePriorityUpdatedEmitter;
+    private readonly afterEdgeUpdatedEmitter;
+    readonly onAfterEdgeUpdated: EventHandler<unknown>;
+    private readonly afterEdgePriorityUpdatedEmitter;
     readonly onAfterEdgePriorityUpdated: EventHandler<unknown>;
-    private readonly onBeforeEdgeRemovedEmitter;
+    private readonly beforeEdgeRemovedEmitter;
     readonly onBeforeEdgeRemoved: EventHandler<unknown>;
-    private readonly onBeforeClearEmitter;
+    private readonly beforeClearEmitter;
     readonly onBeforeClear: EventHandler<void>;
     constructor();
     addNode(request: AddNodeRequest_2): void;
     getAllNodeIds(): readonly unknown[];
     getNode(nodeId: unknown): NodePayload | undefined;
-    updateNodeCoordinates(nodeId: unknown, request: UpdateNodeCoordinatesRequest): void;
-    updateNodePriority(nodeId: unknown, priority: number): void;
+    updateNode(nodeId: unknown, request: UpdateNodeRequest_2): void;
     removeNode(nodeId: unknown): void;
     addPort(request: AddPortRequest): void;
     getPort(portId: unknown): PortPayload | undefined;
-    updatePortDirection(portId: unknown, direction: number): void;
+    updatePort(portId: unknown, request: UpdatePortRequest_2): void;
     getAllPortIds(): readonly unknown[];
     getNodePortIds(nodeId: unknown): readonly unknown[] | undefined;
     removePort(portId: unknown): void;
     addEdge(request: AddEdgeRequest_2): void;
-    updateEdgeShape(edgeId: unknown, shape: EdgeShape): void;
-    updateEdgeAdjacentPorts(edgeId: unknown, request: UpdateEdgeAdjacentPortsRequest): void;
-    updateEdgePriority(edgeId: unknown, priority: number): void;
+    updateEdge(edgeId: unknown, request: UpdateEdgeRequest_2): void;
     getAllEdgeIds(): readonly unknown[];
     getEdge(edgeId: unknown): EdgePayload | undefined;
     removeEdge(edgeId: unknown): void;
@@ -702,11 +737,6 @@ declare interface TransformState {
     readonly y: number;
 }
 
-declare interface UpdateEdgeAdjacentPortsRequest {
-    readonly from: unknown | undefined;
-    readonly to: unknown | undefined;
-}
-
 export declare interface UpdateEdgeRequest {
     readonly from?: unknown | undefined;
     readonly to?: unknown | undefined;
@@ -715,18 +745,19 @@ export declare interface UpdateEdgeRequest {
 }
 
 declare interface UpdateEdgeRequest_2 {
+    readonly from?: unknown;
+    readonly to?: unknown;
+    readonly shape?: EdgeShape;
+    readonly priority?: number;
+}
+
+declare interface UpdateEdgeRequest_3 {
     readonly from?: unknown | undefined;
     readonly to?: unknown | undefined;
     readonly shape?: EdgeShape | undefined;
     readonly priority?: number | undefined;
 }
 
-declare interface UpdateNodeCoordinatesRequest {
-    readonly x: number | undefined;
-    readonly y: number | undefined;
-    readonly centerFn: CenterFn | undefined;
-}
-
 export declare interface UpdateNodeRequest {
     readonly x?: number | undefined;
     readonly y?: number | undefined;
@@ -735,6 +766,13 @@ export declare interface UpdateNodeRequest {
 }
 
 declare interface UpdateNodeRequest_2 {
+    readonly x?: number;
+    readonly y?: number;
+    readonly centerFn?: CenterFn;
+    readonly priority?: number;
+}
+
+declare interface UpdateNodeRequest_3 {
     readonly x?: number | undefined;
     readonly y?: number | undefined;
     readonly priority?: number | undefined;
@@ -749,6 +787,10 @@ declare interface UpdatePortRequest_2 {
     readonly direction?: number;
 }
 
+declare interface UpdatePortRequest_3 {
+    readonly direction?: number;
+}
+
 export declare interface VerticalEdgeParams {
     readonly color?: string | undefined;
     readonly width?: number | undefined;
@@ -787,11 +829,12 @@ declare type VerticalEdgeShapeConfig = {
 } & VerticalEdgeParams;
 
 /**
- * This entity is responsible for providing viewport transformation state to the
- * end user in a safe way
+ * This entity is responsible for providing viewport API
  */
 export declare class Viewport {
     private readonly transformer;
+    readonly onBeforeUpdated: EventHandler<void>;
+    readonly onAfterUpdated: EventHandler<void>;
     constructor(transformer: ViewportStore);
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
@@ -803,8 +846,10 @@ export declare class Viewport {
 declare class ViewportStore {
     private viewportMatrix;
     private contentMatrix;
-    private readonly emitter;
-    readonly onAfterUpdate: EventHandler<void>;
+    private readonly afterUpdateEmitter;
+    readonly onAfterUpdated: EventHandler<void>;
+    private readonly beforeUpdateEmitter;
+    readonly onBeforeUpdated: EventHandler<void>;
     constructor();
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;