@html-graph/html-graph 1.1.0 → 1.2.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;
 }
@@ -90,6 +90,21 @@ declare interface BezierEdgeShape_2 {
     readonly detourDirection?: number | undefined;
 }
 
+declare interface BezierEdgeShape_3 {
+    readonly type?: "bezier" | undefined;
+    readonly color?: string | undefined;
+    readonly width?: number | undefined;
+    readonly curvature?: number | undefined;
+    readonly arrowLength?: number | undefined;
+    readonly arrowWidth?: number | undefined;
+    readonly hasSourceArrow?: boolean | undefined;
+    readonly hasTargetArrow?: boolean | undefined;
+    readonly cycleRadius?: number | undefined;
+    readonly smallCycleRadius?: number | undefined;
+    readonly detourDistance?: number | undefined;
+    readonly detourDirection?: number | undefined;
+}
+
 export declare interface Canvas {
     /**
      * provides api for accessing graph model
@@ -172,42 +187,73 @@ declare class CanvasBuilder {
     private coreOptions;
     private dragOptions;
     private transformOptions;
-    private isDraggable;
-    private isTransformable;
+    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;
+    /**
+     * builds final canvas
+     */
     build(): Canvas;
 }
 export { CanvasBuilder }
 export { CanvasBuilder as HtmlGraphBuilder }
 
 /**
- * Provides low level API for acting on graph
+ * @deprecated
  */
 export declare class CanvasCore implements Canvas {
-    private readonly apiOptions?;
     readonly transformation: PublicViewportTransformer;
     readonly model: PublicGraphStore;
-    private readonly canvasController;
-    private readonly edgeShapeFactory;
-    constructor(apiOptions?: CoreOptions | undefined);
+    private readonly internalTransformation;
+    private readonly internalModel;
+    private readonly graphStoreController;
+    private readonly htmlView;
+    private readonly onAfterNodeAdded;
+    private readonly onAfterEdgeAdded;
+    private readonly onAfterEdgeShapeUpdated;
+    private readonly onAfterEdgePriorityUpdated;
+    private readonly onAfterEdgeUpdated;
+    private readonly onAfterPortUpdated;
+    private readonly onAfterNodePriorityUpdated;
+    private readonly onAfterNodeUpdated;
+    private readonly onBeforeEdgeRemoved;
+    private readonly onBeforeNodeRemoved;
+    constructor(apiOptions?: CoreOptions_2);
     attach(element: HTMLElement): CanvasCore;
     detach(): CanvasCore;
     addNode(request: AddNodeRequest): CanvasCore;
     updateNode(nodeId: unknown, request?: UpdateNodeRequest): CanvasCore;
     removeNode(nodeId: unknown): CanvasCore;
-    addEdge(edge: AddEdgeRequest): CanvasCore;
+    addEdge(request: AddEdgeRequest): CanvasCore;
     updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): CanvasCore;
     removeEdge(edgeId: unknown): CanvasCore;
-    markPort(port: MarkPortRequest): CanvasCore;
+    markPort(request: MarkPortRequest): CanvasCore;
     updatePort(portId: string, request?: UpdatePortRequest): CanvasCore;
     unmarkPort(portId: string): CanvasCore;
     patchViewportMatrix(request: PatchMatrixRequest): CanvasCore;
@@ -220,6 +266,8 @@ export declare type CenterFn = (width: number, height: number) => Point;
 
 declare type ConstantPriority = number;
 
+declare type ConstantPriority_2 = number;
+
 export declare interface CoreOptions {
     /**
      * nodes related behavior
@@ -259,8 +307,49 @@ export declare interface CoreOptions {
     };
 }
 
+declare interface CoreOptions_2 {
+    /**
+     * nodes related behavior
+     */
+    readonly nodes?: {
+        /**
+         * specifies how to determine center of node
+         * center of nodes specified in addNode method by x and y
+         */
+        readonly centerFn?: CenterFn;
+        /**
+         * specifies default z-index value
+         */
+        readonly priority?: Priority_2;
+    };
+    /**
+     * ports related behavior
+     */
+    readonly ports?: {
+        /**
+         * specifies default direction of port
+         */
+        readonly direction?: number;
+    };
+    /**
+     *edges related behavior
+     */
+    readonly edges?: {
+        /**
+         * specifies default controller
+         */
+        readonly shape?: EdgeShape_3;
+        /**
+         * specifies default z-index value
+         */
+        readonly priority?: Priority_2;
+    };
+}
+
 declare type CustomPriority = PriorityFn;
 
+declare type CustomPriority_2 = PriorityFn;
+
 export declare interface DragOptions {
     readonly moveOnTop?: boolean;
     readonly mouse?: {
@@ -271,7 +360,7 @@ export declare interface DragOptions {
     readonly events?: {
         readonly onNodeDrag?: (payload: NodeDragPayload) => void;
         readonly onBeforeNodeDrag?: (payload: NodeDragPayload) => boolean;
-        readonly onNodeDragFinished?: (nodeId: NodeDragPayload) => void;
+        readonly onNodeDragFinished?: (payload: NodeDragPayload) => void;
     };
 }
 
@@ -304,8 +393,28 @@ export declare interface EdgeShape {
 
 declare type EdgeShape_2 = BezierEdgeShape_2 | StraightEdgeShape_2 | HorizontalEdgeShape_2 | VerticalEdgeShape_2 | EdgeShapeFactory;
 
+declare type EdgeShape_3 = BezierEdgeShape_3 | StraightEdgeShape_3 | HorizontalEdgeShape_3 | VerticalEdgeShape_3 | EdgeShapeFactory_2;
+
 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;
+}
+
 export declare interface GraphEdge {
     readonly from: unknown;
     readonly to: unknown;
@@ -325,6 +434,9 @@ export declare interface GraphPort {
     readonly direction: number;
 }
 
+/**
+ * This entity is responsible for storing state of graph
+ */
 declare class GraphStore {
     private readonly nodes;
     private readonly ports;
@@ -409,12 +521,29 @@ declare interface HorizontalEdgeShape_2 {
     readonly detourDirection?: number | undefined;
 }
 
+declare interface HorizontalEdgeShape_3 {
+    readonly type: "horizontal";
+    readonly color?: string | undefined;
+    readonly width?: number | undefined;
+    readonly arrowLength?: number | undefined;
+    readonly arrowWidth?: number | undefined;
+    readonly arrowOffset?: number | undefined;
+    readonly hasSourceArrow?: boolean | undefined;
+    readonly hasTargetArrow?: boolean | undefined;
+    readonly cycleSquareSide?: number | undefined;
+    readonly roundness?: number | undefined;
+    readonly detourDistance?: number | undefined;
+    readonly detourDirection?: number | undefined;
+}
+
 export declare class HtmlGraphError extends Error {
     readonly name = "HtmlGraphError";
 }
 
 declare type IncrementalPriority = "incremental";
 
+declare type IncrementalPriority_2 = "incremental";
+
 export declare type MarkNodePortRequest = {
     readonly id?: unknown | undefined;
     readonly element: HTMLElement;
@@ -422,10 +551,10 @@ export declare type MarkNodePortRequest = {
 };
 
 export declare interface MarkPortRequest {
-    readonly id?: unknown | undefined;
+    readonly id?: unknown;
     readonly element: HTMLElement;
     readonly nodeId: unknown;
-    readonly direction?: number | undefined;
+    readonly direction?: number;
 }
 
 export declare interface NodeDragPayload {
@@ -467,8 +596,13 @@ declare interface PortPayload {
 
 declare type Priority = ConstantPriority | IncrementalPriority | SharedIncrementalPriority | CustomPriority;
 
+declare type Priority_2 = ConstantPriority_2 | IncrementalPriority_2 | SharedIncrementalPriority_2 | CustomPriority_2;
+
 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);
@@ -490,6 +624,10 @@ export declare class PublicGraphStore {
     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);
@@ -497,6 +635,13 @@ export declare class PublicViewportTransformer {
     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;
@@ -520,7 +665,7 @@ export declare class ResizeReactiveNodesCanvas implements Canvas {
     patchContentMatrix(request: PatchMatrixRequest): ResizeReactiveNodesCanvas;
     clear(): ResizeReactiveNodesCanvas;
     destroy(): void;
-    private reactNodeChange;
+    private handleNodeResize;
 }
 
 export declare interface ScaleLimitPreprocessorParams {
@@ -530,6 +675,8 @@ export declare interface ScaleLimitPreprocessorParams {
 
 declare type SharedIncrementalPriority = "shared-incremental";
 
+declare type SharedIncrementalPriority_2 = "shared-incremental";
+
 export declare interface ShiftLimitPreprocessorParams {
     readonly minX: number | null;
     readonly maxX: number | null;
@@ -585,6 +732,21 @@ declare interface StraightEdgeShape_2 {
     readonly detourDirection?: number | undefined;
 }
 
+declare interface StraightEdgeShape_3 {
+    readonly type: "straight";
+    readonly color?: string | undefined;
+    readonly width?: number | undefined;
+    readonly arrowLength?: number | undefined;
+    readonly arrowWidth?: number | undefined;
+    readonly arrowOffset?: number | undefined;
+    readonly hasSourceArrow?: boolean | undefined;
+    readonly hasTargetArrow?: boolean | undefined;
+    readonly cycleSquareSide?: number | undefined;
+    readonly roundness?: number | undefined;
+    readonly detourDistance?: number | undefined;
+    readonly detourDirection?: number | undefined;
+}
+
 export declare interface TransformOptions {
     readonly scale?: {
         readonly mouseWheelSensitivity?: number;
@@ -652,7 +814,7 @@ export declare interface UpdateNodeRequest {
 }
 
 export declare interface UpdatePortRequest {
-    readonly direction?: number | undefined;
+    readonly direction?: number;
 }
 
 export declare class UserDraggableNodesCanvas implements Canvas {
@@ -786,9 +948,30 @@ declare interface VerticalEdgeShape_2 {
     readonly detourDirection?: number | undefined;
 }
 
+declare interface VerticalEdgeShape_3 {
+    readonly type: "vertical";
+    readonly color?: string | undefined;
+    readonly width?: number | undefined;
+    readonly arrowLength?: number | undefined;
+    readonly arrowWidth?: number | undefined;
+    readonly arrowOffset?: number | undefined;
+    readonly hasSourceArrow?: boolean | undefined;
+    readonly hasTargetArrow?: boolean | undefined;
+    readonly cycleSquareSide?: number | undefined;
+    readonly roundness?: number | undefined;
+    readonly detourDistance?: number | undefined;
+    readonly detourDirection?: number | undefined;
+}
+
+/**
+ * This entity is responsible for storing viewport transformation
+ */
 declare class ViewportTransformer {
     private viewportMatrix;
     private contentMatrix;
+    private readonly emitter;
+    readonly onAfterUpdate: EventHandler<void>;
+    constructor();
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
     patchViewportMatrix(matrix: PatchTransformRequest): void;