@html-graph/html-graph 2.2.2 → 2.4.0

package/dist/html-graph.d.ts

@@ -227,13 +227,13 @@ declare interface CanvasController {
     attach(element: HTMLElement): void;
     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;
@@ -333,11 +333,11 @@ declare type EdgeShapeConfig = BezierEdgeShapeConfig | StraightEdgeShapeConfig |
 
 declare type EdgeShapeFactory = () => EdgeShape;
 
-declare interface EventEmitter<T> {
+export declare interface EventEmitter<T> {
     emit(payload: T): void;
 }
 
-declare interface EventHandler<T> {
+export declare interface EventHandler<T> {
     subscribe(callback: (payload: T) => void): void;
     unsubscribe(callback: (payload: T) => void): void;
 }
@@ -354,6 +354,44 @@ 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>;
+    readonly onBeforeClear: EventHandler<void>;
     constructor(graphStore: GraphStore);
     getNode(nodeId: unknown): GraphNode | null;
     getAllNodeIds(): readonly unknown[];
@@ -407,18 +445,46 @@ declare class GraphStore {
     private readonly incommingEdges;
     private readonly outcommingEdges;
     private readonly cycleEdges;
+    private readonly afterNodeAddedEmitter;
+    readonly onAfterNodeAdded: EventHandler<unknown>;
+    private readonly afterNodeUpdatedEmitter;
+    readonly onAfterNodeUpdated: EventHandler<unknown>;
+    private readonly afterNodePriorityUpdatedEmitter;
+    readonly onAfterNodePriorityUpdated: EventHandler<unknown>;
+    private readonly beforeNodeRemovedEmitter;
+    readonly onBeforeNodeRemoved: EventHandler<unknown>;
+    private readonly afterPortAddedEmitter;
+    readonly onAfterPortAdded: EventHandler<unknown>;
+    private readonly afterPortUpdatedEmitter;
+    readonly onAfterPortUpdated: EventHandler<unknown>;
+    private readonly beforePortRemovedEmitter;
+    readonly onBeforePortRemoved: EventHandler<unknown>;
+    private readonly afterEdgeAddedEmitter;
+    readonly onAfterEdgeAdded: EventHandler<unknown>;
+    private readonly afterEdgeShapeUpdatedEmitter;
+    readonly onAfterEdgeShapeUpdated: EventHandler<unknown>;
+    private readonly afterEdgeUpdatedEmitter;
+    readonly onAfterEdgeUpdated: EventHandler<unknown>;
+    private readonly afterEdgePriorityUpdatedEmitter;
+    readonly onAfterEdgePriorityUpdated: EventHandler<unknown>;
+    private readonly beforeEdgeRemovedEmitter;
+    readonly onBeforeEdgeRemoved: EventHandler<unknown>;
+    private readonly beforeClearEmitter;
+    readonly onBeforeClear: EventHandler<void>;
+    constructor();
     addNode(request: AddNodeRequest_2): void;
     getAllNodeIds(): readonly unknown[];
     getNode(nodeId: unknown): NodePayload | undefined;
+    updateNode(nodeId: unknown, request: UpdateNodeRequest_2): void;
     removeNode(nodeId: unknown): void;
     addPort(request: AddPortRequest): void;
     getPort(portId: unknown): PortPayload | undefined;
+    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;
-    updateEdgeFrom(edgeId: unknown, from: unknown): void;
-    updateEdgeTo(edgeId: unknown, to: unknown): void;
+    updateEdge(edgeId: unknown, request: UpdateEdgeRequest_2): void;
     getAllEdgeIds(): readonly unknown[];
     getEdge(edgeId: unknown): EdgePayload | undefined;
     removeEdge(edgeId: unknown): void;
@@ -431,6 +497,8 @@ declare class GraphStore {
     getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[];
     getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[];
     getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[];
+    private addEdgeInternal;
+    private removeEdgeInternal;
 }
 
 export declare interface HorizontalEdgeParams {
@@ -664,6 +732,13 @@ 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;
@@ -678,6 +753,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;
@@ -692,6 +774,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;
@@ -730,11 +816,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;
@@ -746,8 +833,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;