@html-graph/html-graph 3.2.0 → 3.4.0

package/dist/html-graph.d.ts

@@ -42,7 +42,7 @@ declare interface AddPortRequest {
     readonly direction: number;
 }
 
-declare interface BackgroundOptions {
+export declare interface BackgroundConfig {
     readonly tileDimensions?: {
         readonly width?: number;
         readonly height?: number;
@@ -124,12 +124,15 @@ export declare class Canvas {
     private readonly onBeforeEdgeRemoved;
     private readonly onBeforeClear;
     private readonly onBeforeDestroyEmitter;
+    /**
+     * emits event just before destruction of canvas
+     */
     readonly onBeforeDestroy: EventHandler<void>;
     constructor(
     /**
      * @deprecated access element directly instead
      */
-    element: HTMLElement, graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, options: CanvasDefaults);
+    element: HTMLElement, graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, defaults: CanvasDefaults);
     /**
      * adds new node
      */
@@ -195,15 +198,23 @@ export declare class Canvas {
 export declare class CanvasBuilder {
     private element;
     private canvasDefaults;
-    private dragOptions;
-    private transformOptions;
-    private backgroundOptions;
-    private virtualScrollOptions;
+    private dragConfig;
+    private transformConfig;
+    private backgroundConfig;
+    private connectablePortsConfig;
+    private virtualScrollConfig;
     private hasDraggableNode;
     private hasTransformableViewport;
     private hasResizeReactiveNodes;
     private hasBackground;
+    private hasUserConnectablePorts;
     private boxRenderingTrigger;
+    private readonly window;
+    constructor(element?: HTMLElement);
+    /**
+     * @deprecated
+     * use `new CanvasBuilder(element);` instead
+     */
     setElement(element: HTMLElement): CanvasBuilder;
     /**
      * specifies default values for graph entities
@@ -212,11 +223,11 @@ export declare class CanvasBuilder {
     /**
      * enables nodes draggable by user
      */
-    enableUserDraggableNodes(options?: DragOptions): CanvasBuilder;
+    enableUserDraggableNodes(options?: DraggableNodesConfig): CanvasBuilder;
     /**
      * enables viewport transformable by user
      */
-    enableUserTransformableViewport(options?: TransformOptions): CanvasBuilder;
+    enableUserTransformableViewport(config?: ViewportTransformConfig): CanvasBuilder;
     /**
      * enables automatic edges update on node resize
      */
@@ -225,8 +236,19 @@ export declare class CanvasBuilder {
      * sets emitter for rendering graph inside bounded area
      */
     enableBoxAreaRendering(trigger: EventSubject<RenderingBox>): CanvasBuilder;
-    enableVirtualScroll(options: VirtualScrollOptions): CanvasBuilder;
-    enableBackground(options?: BackgroundOptions): 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;
     /**
      * builds final canvas
      */
@@ -279,6 +301,21 @@ export declare interface CanvasDefaults {
 
 export declare type CenterFn = (width: number, height: number) => Point;
 
+declare interface ConnectablePortsConfig {
+    readonly connectionTypeResolver?: ConnectionTypeResolver;
+    readonly connectionPreprocessor?: ConnectionPreprocessor;
+    readonly mouseDownEventVerifier?: MouseEventVerifier;
+    readonly events?: {
+        readonly onAfterEdgeCreated?: (edgeId: unknown) => void;
+    };
+}
+export { ConnectablePortsConfig }
+export { ConnectablePortsConfig as ConnectablePortsOptions }
+
+export declare type ConnectionPreprocessor = (request: AddEdgeRequest) => AddEdgeRequest | null;
+
+export declare type ConnectionTypeResolver = (portId: unknown) => "direct" | "reverse" | null;
+
 declare type ConstantPriority = number;
 
 declare type CustomPriority = PriorityFn;
@@ -288,12 +325,12 @@ declare interface DotsRenderer {
     readonly color?: string;
 }
 
-export declare interface DragOptions {
+declare interface DraggableNodesConfig {
     readonly moveOnTop?: boolean;
     readonly mouse?: {
         readonly dragCursor?: string | null;
-        readonly mouseDownEventVerifier?: (event: MouseEvent) => boolean;
-        readonly mouseUpEventVerifier?: (event: MouseEvent) => boolean;
+        readonly mouseDownEventVerifier?: MouseEventVerifier;
+        readonly mouseUpEventVerifier?: MouseEventVerifier;
     };
     readonly events?: {
         readonly onNodeDrag?: (payload: NodeDragPayload) => void;
@@ -301,6 +338,8 @@ export declare interface DragOptions {
         readonly onNodeDragFinished?: (payload: NodeDragPayload) => void;
     };
 }
+export { DraggableNodesConfig as DragOptions }
+export { DraggableNodesConfig }
 
 declare interface EdgePayload {
     readonly from: unknown;
@@ -560,6 +599,8 @@ export declare interface MarkPortRequest {
     readonly direction?: number;
 }
 
+export declare type MouseEventVerifier = (event: MouseEvent) => boolean;
+
 export declare interface NodeDragPayload {
     readonly nodeId: unknown;
     readonly element: HTMLElement;
@@ -665,37 +706,13 @@ declare type StraightEdgeShapeConfig = {
     readonly type: "straight";
 } & StraightEdgeParams;
 
-export declare interface TransformOptions {
-    readonly scale?: {
-        readonly mouseWheelSensitivity?: number;
-        readonly mouseWheelEventVerifier?: (event: WheelEvent) => boolean;
-        readonly wheelFinishTimeout?: number;
-    };
-    readonly shift?: {
-        readonly cursor?: string | null;
-        readonly mouseDownEventVerifier?: (event: MouseEvent) => boolean;
-        readonly mouseUpEventVerifier?: (event: MouseEvent) => boolean;
-    };
-    readonly transformPreprocessor?: TransformPreprocessorOption | TransformPreprocessorOption[];
-    readonly events?: {
-        readonly onTransformStarted?: () => void;
-        readonly onTransformFinished?: () => void;
-        readonly onBeforeTransformChange?: () => void;
-        readonly onTransformChange?: () => void;
-        readonly onResizeTransformStarted?: () => void;
-        readonly onResizeTransformFinished?: () => void;
-    };
-}
-
 export declare interface TransformPayload {
     readonly scale: number;
     readonly x: number;
     readonly y: number;
 }
 
-export declare type TransformPreprocessorFn = (params: TransformPreprocessorParams) => TransformPayload;
-
-declare type TransformPreprocessorOption = {
+declare type TransformPreprocessorConfig = {
     readonly type: "scale-limit";
     readonly minContentScale?: number;
     readonly maxContentScale?: number;
@@ -707,6 +724,8 @@ declare type TransformPreprocessorOption = {
     readonly maxY?: number;
 } | TransformPreprocessorFn;
 
+export declare type TransformPreprocessorFn = (params: TransformPreprocessorParams) => TransformPayload;
+
 export declare interface TransformPreprocessorParams {
     readonly prevTransform: TransformPayload;
     readonly nextTransform: TransformPayload;
@@ -797,10 +816,10 @@ declare type VerticalEdgeShapeConfig = {
  * Responsibility: Provides access to viewport state for end user
  */
 export declare class Viewport {
-    private readonly transformer;
+    private readonly viewportStore;
     readonly onBeforeUpdated: EventHandler<void>;
     readonly onAfterUpdated: EventHandler<void>;
-    constructor(transformer: ViewportStore);
+    constructor(viewportStore: ViewportStore);
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
 }
@@ -822,7 +841,31 @@ declare class ViewportStore {
     patchContentMatrix(matrix: PatchTransformRequest): void;
 }
 
-declare interface VirtualScrollOptions {
+declare interface ViewportTransformConfig {
+    readonly scale?: {
+        readonly mouseWheelSensitivity?: number;
+        readonly mouseWheelEventVerifier?: (event: WheelEvent) => boolean;
+        readonly wheelFinishTimeout?: number;
+    };
+    readonly shift?: {
+        readonly cursor?: string | null;
+        readonly mouseDownEventVerifier?: MouseEventVerifier;
+        readonly mouseUpEventVerifier?: MouseEventVerifier;
+    };
+    readonly transformPreprocessor?: TransformPreprocessorConfig | TransformPreprocessorConfig[];
+    readonly events?: {
+        readonly onTransformStarted?: () => void;
+        readonly onTransformFinished?: () => void;
+        readonly onBeforeTransformChange?: () => void;
+        readonly onTransformChange?: () => void;
+        readonly onResizeTransformStarted?: () => void;
+        readonly onResizeTransformFinished?: () => void;
+    };
+}
+export { ViewportTransformConfig as TransformOptions }
+export { ViewportTransformConfig }
+
+export declare interface VirtualScrollConfig {
     readonly nodeContainingRadius: {
         readonly vertical: number;
         readonly horizontal: number;