@html-graph/html-graph 3.20.0 → 4.0.0

package/dist/html-graph.d.ts

@@ -94,10 +94,6 @@ declare type BezierEdgeShapeConfig = {
 } & BezierEdgeParams;
 
 export declare class Canvas {
-    /**
-     * @deprecated access element directly instead
-     */
-    readonly element: HTMLElement;
     private readonly graphStore;
     private readonly viewportStore;
     private readonly htmlView;
@@ -131,11 +127,7 @@ export declare class Canvas {
      * 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, params: CanvasParams);
+    constructor(graphStore: GraphStore, viewportStore: ViewportStore, htmlView: HtmlView, params: CanvasParams);
     /**
      * adds new node
      */
@@ -196,7 +188,8 @@ export declare class Canvas {
 }
 
 export declare class CanvasBuilder {
-    private element;
+    private readonly element;
+    private used;
     private canvasDefaults;
     private dragConfig;
     private transformConfig;
@@ -212,12 +205,7 @@ export declare class CanvasBuilder {
     private hasUserDraggableEdges;
     private boxRenderingTrigger;
     private readonly window;
-    constructor(element?: HTMLElement);
-    /**
-     * @deprecated
-     * use `new CanvasBuilder(element);` instead
-     */
-    setElement(element: HTMLElement): CanvasBuilder;
+    constructor(element: HTMLElement);
     /**
      * specifies default values for graph entities
      */
@@ -230,21 +218,10 @@ export declare class CanvasBuilder {
      * enables viewport transformable by user
      */
     enableUserTransformableViewport(config?: ViewportTransformConfig): CanvasBuilder;
-    /**
-     * @deprecated
-     * use enableNodeResizeReactiveEdges instead
-     */
-    enableResizeReactiveNodes(): CanvasBuilder;
     /**
      * enables automatic edges update on node resize
      */
     enableNodeResizeReactiveEdges(): CanvasBuilder;
-    /**
-     * @deprecated
-     * do not use
-     * sets emitter for rendering graph inside bounded area
-     */
-    enableBoxAreaRendering(trigger: EventSubject<RenderingBox>): CanvasBuilder;
     /**
      * enables built-in virtual scroll behavior, when only nodes and edges close
      * to viewport are rendered
@@ -263,11 +240,10 @@ export declare class CanvasBuilder {
      * builds final canvas
      */
     build(): Canvas;
-    /**
-     * @deprecated
-     * CanvasBuilder should be single use object
-     */
-    private reset;
+}
+
+export declare class CanvasBuilderError extends Error {
+    readonly name = "CanvasBuilderError";
 }
 
 export declare interface CanvasDefaults {
@@ -309,6 +285,10 @@ export declare interface CanvasDefaults {
     };
 }
 
+export declare class CanvasError extends Error {
+    readonly name = "CanvasError";
+}
+
 declare interface CanvasParams {
     readonly nodes: {
         readonly centerFn: CenterFn;
@@ -325,7 +305,7 @@ declare interface CanvasParams {
 
 export declare type CenterFn = (width: number, height: number) => Point;
 
-declare interface ConnectablePortsConfig {
+export declare interface ConnectablePortsConfig {
     readonly edgeShape?: EdgeShapeConfig;
     readonly connectionTypeResolver?: ConnectionTypeResolver;
     readonly connectionPreprocessor?: ConnectionPreprocessor;
@@ -334,12 +314,13 @@ declare interface ConnectablePortsConfig {
     readonly dragPortDirection?: number | undefined;
     readonly events?: {
         readonly onAfterEdgeCreated?: (edgeId: unknown) => void;
-        readonly onEdgeCreationInterrupted?: (staticPortId: unknown, isDirect: boolean) => void;
+        readonly onEdgeCreationInterrupted?: (params: {
+            readonly staticPortId: unknown;
+            readonly isDirect: boolean;
+        }) => void;
         readonly onEdgeCreationPrevented?: (request: AddEdgeRequest) => void;
     };
 }
-export { ConnectablePortsConfig }
-export { ConnectablePortsConfig as ConnectablePortsOptions }
 
 export declare enum ConnectionCategory {
     Line = "line",
@@ -406,23 +387,21 @@ declare interface DraggableEdgesConfig {
     };
 }
 
-declare interface DraggableNodesConfig {
+export declare interface DraggableNodesConfig {
     readonly moveOnTop?: boolean;
     readonly moveEdgesOnTop?: boolean;
+    readonly gridSize?: number | null;
+    readonly nodeDragVerifier?: (nodeId: unknown) => boolean;
     readonly mouse?: {
         readonly dragCursor?: string | null;
         readonly mouseDownEventVerifier?: MouseEventVerifier;
         readonly mouseUpEventVerifier?: MouseEventVerifier;
     };
-    readonly gridSize?: number | null;
     readonly events?: {
-        readonly onNodeDrag?: (payload: NodeDragPayload) => void;
-        readonly onBeforeNodeDrag?: (payload: NodeDragPayload) => boolean;
-        readonly onNodeDragFinished?: (payload: NodeDragPayload) => void;
+        readonly onNodeDrag?: (nodeId: unknown) => void;
+        readonly onNodeDragFinished?: (nodeId: unknown) => void;
     };
 }
-export { DraggableNodesConfig as DragOptions }
-export { DraggableNodesConfig }
 
 export declare type DraggingEdgeResolver = (portId: unknown) => unknown | null;
 
@@ -431,8 +410,6 @@ declare interface EdgePath {
     readonly midpoint: Point;
 }
 
-declare type EdgePathFactory = (sourceDirection: Point, targetDirection: Point, to: Point, flipX: number, flipY: number) => EdgePath;
-
 declare interface EdgePayload {
     readonly from: unknown;
     readonly to: unknown;
@@ -452,16 +429,6 @@ export declare interface EdgeRenderPort {
     readonly width: number;
     readonly height: number;
     readonly direction: number;
-    /**
-     * @deprecated
-     * use category instead
-     */
-    readonly portId: unknown;
-    /**
-     * @deprecated
-     * use category instead
-     */
-    readonly nodeId: unknown;
 }
 
 export declare interface EdgeShape {
@@ -473,20 +440,9 @@ declare type EdgeShapeConfig = BezierEdgeShapeConfig | StraightEdgeShapeConfig |
 
 declare type EdgeShapeFactory = (edgeId: unknown) => EdgeShape;
 
-export declare interface EventEmitter<T> {
-    emit(payload: T): void;
-}
-
-export 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;
+declare interface EventHandler<T> {
     subscribe(callback: (payload: T) => void): void;
     unsubscribe(callback: (payload: T) => void): void;
-    emit(payload: T): void;
 }
 
 export declare class Graph {
@@ -512,29 +468,14 @@ export declare class Graph {
     getAllPortIds(): readonly unknown[];
     getNodePortIds(nodeId: unknown): readonly unknown[] | null;
     getElementPortIds(element: HTMLElement): readonly unknown[];
-    /**
-     * @deprecated
-     * use getElementPortIds instead
-     */
-    getElementPortsIds(element: HTMLElement): readonly unknown[];
     getAllEdgeIds(): readonly unknown[];
     getEdge(edgeId: unknown): GraphEdge | null;
     getPortIncomingEdgeIds(portId: unknown): readonly unknown[] | null;
     getPortOutgoingEdgeIds(portId: unknown): readonly unknown[] | null;
-    /**
-     * @deprecated
-     * use getPortOutgoingEdgeIds instead
-     */
-    getPortOutcomingEdgeIds(portId: unknown): readonly unknown[] | null;
     getPortCycleEdgeIds(portId: unknown): readonly unknown[] | null;
     getPortAdjacentEdgeIds(portId: unknown): readonly unknown[] | null;
     getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
     getNodeOutgoingEdgeIds(nodeId: unknown): readonly unknown[] | null;
-    /**
-     * @deprecated
-     * use getNodeOutgoingEdgeIds instead
-     */
-    getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[] | null;
     getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[] | null;
     getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[] | null;
 }
@@ -638,11 +579,6 @@ export declare interface HorizontalEdgeParams {
     readonly cycleSquareSide?: number | undefined;
     readonly roundness?: number | undefined;
     readonly detourDistance?: number | undefined;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly detourDirection?: number | undefined;
 }
 
 export declare class HorizontalEdgeShape implements StructuredEdgeShape {
@@ -672,10 +608,6 @@ declare type HorizontalEdgeShapeConfig = {
     readonly type: "horizontal";
 } & HorizontalEdgeParams;
 
-export declare class HtmlGraphError extends Error {
-    readonly name = "HtmlGraphError";
-}
-
 declare interface HtmlView {
     attachNode(nodeId: unknown): void;
     detachNode(nodeId: unknown): void;
@@ -697,10 +629,7 @@ export declare class InteractiveEdgeError extends Error {
 }
 
 export declare interface InteractiveEdgeParams {
-    /**
-     * TODO: rename to 'radius'
-     */
-    readonly width?: number;
+    readonly distance?: number;
 }
 
 export declare class InteractiveEdgeShape implements StructuredEdgeShape {
@@ -719,31 +648,6 @@ export declare class InteractiveEdgeShape implements StructuredEdgeShape {
     render(params: EdgeRenderParams): void;
 }
 
-export declare interface LineEdgeParams {
-    readonly width: number;
-    readonly color: string;
-    readonly arrowLength: number;
-    readonly arrowWidth: number;
-    readonly hasSourceArrow: boolean;
-    readonly hasTargetArrow: boolean;
-    readonly createCyclePath: EdgePathFactory;
-    readonly createDetourPath: EdgePathFactory;
-    readonly createLinePath: EdgePathFactory;
-}
-
-export declare class LineEdgeShape implements StructuredEdgeShape {
-    private readonly params;
-    readonly svg: SVGSVGElement;
-    readonly group: SVGGElement;
-    readonly line: SVGPathElement;
-    readonly sourceArrow: SVGPathElement | null;
-    readonly targetArrow: SVGPathElement | null;
-    readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
-    private readonly afterRenderEmitter;
-    constructor(params: LineEdgeParams);
-    render(params: EdgeRenderParams): void;
-}
-
 export declare type MarkNodePortRequest = {
     readonly id?: unknown | undefined;
     readonly element: HTMLElement;
@@ -757,7 +661,7 @@ export declare interface MarkPortRequest {
     readonly direction?: number;
 }
 
-declare class MidpointEdgeShape implements StructuredEdgeShape {
+export declare class MidpointEdgeShape implements StructuredEdgeShape {
     private readonly baseShape;
     readonly midpointElement: SVGElement;
     readonly group: SVGGElement;
@@ -766,29 +670,12 @@ declare class MidpointEdgeShape implements StructuredEdgeShape {
     readonly targetArrow: SVGPathElement | null;
     readonly onAfterRender: EventHandler<StructuredEdgeRenderModel>;
     readonly svg: SVGSVGElement;
-    /**
-     * @deprecated
-     * use midpointElement instead
-     */
-    readonly medianElement: SVGElement;
     constructor(baseShape: StructuredEdgeShape, midpointElement: SVGElement);
     render(params: EdgeRenderParams): void;
 }
-export { MidpointEdgeShape as MedianEdgeShape }
-export { MidpointEdgeShape }
 
 export declare type MouseEventVerifier = (event: MouseEvent) => boolean;
 
-/**
- * TODO: replace with node ID
- */
-export declare interface NodeDragPayload {
-    readonly nodeId: unknown;
-    readonly element: HTMLElement;
-    readonly x: number;
-    readonly y: number;
-}
-
 declare interface NodePayload {
     readonly element: HTMLElement;
     x: number;
@@ -825,13 +712,6 @@ declare type Priority = ConstantPriority | IncrementalPriority | CustomPriority;
 
 export declare type PriorityFn = () => number;
 
-export declare interface RenderingBox {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-
 export declare interface ScaleLimitPreprocessorParams {
     readonly minContentScale: number | null;
     readonly maxContentScale: number | null;
@@ -980,11 +860,6 @@ export declare interface VerticalEdgeParams {
     readonly cycleSquareSide?: number | undefined;
     readonly roundness?: number | undefined;
     readonly detourDistance?: number | undefined;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly detourDirection?: number | undefined;
 }
 
 export declare class VerticalEdgeShape implements StructuredEdgeShape {
@@ -1016,11 +891,6 @@ declare type VerticalEdgeShapeConfig = {
 
 export declare class Viewport {
     private readonly viewportStore;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly onBeforeUpdated: EventHandler<void>;
     readonly onAfterUpdated: EventHandler<void>;
     constructor(viewportStore: ViewportStore);
     getViewportMatrix(): TransformState;
@@ -1032,12 +902,6 @@ declare class ViewportStore {
     private contentMatrix;
     private readonly afterUpdateEmitter;
     readonly onAfterUpdated: EventHandler<void>;
-    private readonly beforeUpdateEmitter;
-    /**
-     * @deprecated
-     * do not use
-     */
-    readonly onBeforeUpdated: EventHandler<void>;
     constructor();
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
@@ -1045,7 +909,7 @@ declare class ViewportStore {
     patchContentMatrix(matrix: PatchTransformRequest): void;
 }
 
-declare interface ViewportTransformConfig {
+export declare interface ViewportTransformConfig {
     readonly scale?: {
         readonly mouseWheelSensitivity?: number;
         readonly mouseWheelEventVerifier?: (event: WheelEvent) => boolean;
@@ -1066,8 +930,6 @@ declare interface ViewportTransformConfig {
         readonly onResizeTransformFinished?: () => void;
     };
 }
-export { ViewportTransformConfig as TransformOptions }
-export { ViewportTransformConfig }
 
 export declare interface VirtualScrollConfig {
     readonly nodeContainingRadius: {