@html-graph/html-graph 0.0.60 → 0.0.61

package/README.md

@@ -6,14 +6,14 @@
 
 ![CI](https://github.com/html-graph/html-graph/actions/workflows/ci.yml/badge.svg?branch=master)
 
-<a target="_blank" href="https://html-graph.github.io/use-cases/20-advanced-demo/index.html">
+<a target="_blank" href="https://html-graph.github.io/use-cases/020-advanced-demo/index.html">
     <img width="100%" src="https://raw.githubusercontent.com/html-graph/html-graph/master/media/full-demo.gif"/>
 </a>
 
 Instead of connecting nodes directly this library uses concept of ports, which provide greater fexibility at managing edges.
 Port is an entity of a node to which edge can be attached to.
 
-Visit <a target="_blank" href="https://html-graph.github.io">use cases</a> and [use cases implementation](use-cases).
+Visit <a target="_blank" href="https://html-graph.github.io/use-cases">use cases</a> and [use cases implementation](use-cases).
 
 ## Features:
 

package/dist/main.d.ts

@@ -6,6 +6,14 @@ export declare interface AddEdgeRequest {
     readonly priority?: number;
 }
 
+declare interface AddEdgeRequest_2 {
+    readonly edgeId: unknown;
+    readonly from: unknown;
+    readonly to: unknown;
+    readonly shape: EdgeShape;
+    readonly priority: number;
+}
+
 export declare type AddNodePorts = Iterable<MarkNodePortRequest>;
 
 export declare interface AddNodeRequest {
@@ -18,6 +26,23 @@ export declare interface AddNodeRequest {
     readonly priority?: number;
 }
 
+declare interface AddNodeRequest_2 {
+    readonly nodeId: unknown;
+    readonly element: HTMLElement;
+    readonly x: number;
+    readonly y: number;
+    readonly centerFn: CenterFn;
+    readonly priority: number;
+}
+
+declare interface AddPortRequest {
+    readonly portId: unknown;
+    readonly nodeId: unknown;
+    readonly element: HTMLElement;
+    readonly centerFn: CenterFn;
+    readonly direction: number;
+}
+
 export declare class BezierEdgeShape implements EdgeShape {
     private readonly curvature;
     private readonly arrowLength;
@@ -63,7 +88,7 @@ export declare interface Canvas {
     /**
      * updates node absolute coordinates
      */
-    updateNode(nodeId: unknown, request: UpdateNodeRequest): Canvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): Canvas;
     /**
      * removes node from graph
      * all the ports of node get unmarked
@@ -90,7 +115,7 @@ export declare interface Canvas {
     /**
      * updates edge
      */
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest): Canvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): Canvas;
     /**
      * removes edge from graph
      */
@@ -134,16 +159,18 @@ export declare class CanvasCore implements Canvas {
     readonly model: PublicGraphStore;
     private readonly di;
     private readonly edgeShapeFactory;
-    private readonly nodeResizeObserverFactory;
+    private readonly nodes;
+    private readonly nodeIdGenerator;
+    private readonly nodesResizeObserver;
     constructor(apiOptions?: CoreOptions | undefined);
-    addNode(node: AddNodeRequest): CanvasCore;
-    updateNode(nodeId: unknown, request: UpdateNodeRequest): CanvasCore;
+    addNode(request: AddNodeRequest): CanvasCore;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): CanvasCore;
     removeNode(nodeId: unknown): CanvasCore;
     markPort(port: MarkPortRequest): CanvasCore;
     updatePort(portId: string, request?: UpdatePortRequest): CanvasCore;
     unmarkPort(portId: string): CanvasCore;
     addEdge(edge: AddEdgeRequest): CanvasCore;
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest): CanvasCore;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): CanvasCore;
     removeEdge(edgeId: unknown): CanvasCore;
     patchViewportMatrix(request: PatchMatrixRequest): CanvasCore;
     patchContentMatrix(request: PatchMatrixRequest): CanvasCore;
@@ -334,6 +361,13 @@ export declare interface DragOptions {
     };
 }
 
+declare interface EdgePayload {
+    readonly from: unknown;
+    readonly to: unknown;
+    shape: EdgeShape;
+    priority: number;
+}
+
 export declare interface EdgeShape {
     readonly svg: SVGSVGElement;
     update(to: Point, flipX: number, flipY: number, fromDir: number, toDir: number): void;
@@ -369,6 +403,40 @@ export declare interface GraphPort {
     readonly direction: number;
 }
 
+declare class GraphStore {
+    private readonly nodes;
+    private readonly ports;
+    private readonly nodePorts;
+    private readonly portNodeId;
+    private readonly edges;
+    private readonly incommingEdges;
+    private readonly outcommingEdges;
+    private readonly cycleEdges;
+    addNode(request: AddNodeRequest_2): void;
+    getAllNodeIds(): readonly unknown[];
+    getNode(nodeId: unknown): NodePayload | undefined;
+    removeNode(nodeId: unknown): void;
+    addPort(request: AddPortRequest): void;
+    getPort(portId: unknown): PortPayload | undefined;
+    getAllPortIds(): readonly unknown[];
+    getNodePortIds(nodeId: unknown): readonly unknown[] | undefined;
+    getPortNodeId(portId: unknown): unknown | undefined;
+    removePort(portId: unknown): void;
+    addEdge(request: AddEdgeRequest_2): void;
+    getAllEdgeIds(): readonly unknown[];
+    getEdge(edgeId: unknown): EdgePayload | undefined;
+    removeEdge(edgeId: unknown): void;
+    clear(): void;
+    getPortIncomingEdgeIds(portId: unknown): readonly unknown[];
+    getPortOutcomingEdgeIds(portId: unknown): readonly unknown[];
+    getPortCycleEdgeIds(portId: unknown): readonly unknown[];
+    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[];
+    getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[];
+    getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[];
+    getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[];
+    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[];
+}
+
 export declare class HorizontalEdgeShape implements EdgeShape {
     private readonly arrowLength;
     private readonly arrowWidth;
@@ -439,41 +507,65 @@ export declare interface NodeDragPayload {
     readonly y: number;
 }
 
+declare interface NodePayload {
+    element: HTMLElement;
+    x: number;
+    y: number;
+    centerFn: CenterFn;
+    priority: number;
+}
+
 export declare interface PatchMatrixRequest {
     readonly scale?: number;
     readonly dx?: number;
     readonly dy?: number;
 }
 
+declare interface PatchTransformRequest {
+    readonly scale?: number;
+    readonly dx?: number;
+    readonly dy?: number;
+}
+
 export declare interface Point {
     readonly x: number;
     readonly y: number;
 }
 
+declare interface PortPayload {
+    readonly element: HTMLElement;
+    centerFn: CenterFn;
+    direction: number;
+}
+
 declare type Priority = ConstantPriority | IncrementalPriority | SharedIncrementalPriority | CustomPriority;
 
 export declare type PriorityFn = () => number;
 
-export declare interface PublicGraphStore {
+export declare class PublicGraphStore {
+    private readonly graphStore;
+    constructor(graphStore: GraphStore);
+    getNode(nodeId: unknown): GraphNode | null;
     getAllNodeIds(): readonly unknown[];
+    getPort(portId: unknown): GraphPort | null;
     getAllPortIds(): readonly unknown[];
-    getNode(nodeId: unknown): GraphNode | null;
     getNodePortIds(nodeId: unknown): readonly unknown[] | undefined;
-    getPort(portId: unknown): GraphPort | null;
     getPortNodeId(portId: unknown): unknown | null;
     getAllEdgeIds(): readonly unknown[];
     getEdge(edgeId: unknown): GraphEdge | null;
-    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[];
-    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[];
     getPortIncomingEdgeIds(portId: unknown): readonly unknown[];
     getPortOutcomingEdgeIds(portId: unknown): readonly unknown[];
     getPortCycleEdgeIds(portId: unknown): readonly unknown[];
+    getPortAdjacentEdgeIds(portId: unknown): readonly unknown[];
     getNodeIncomingEdgeIds(nodeId: unknown): readonly unknown[];
     getNodeOutcomingEdgeIds(nodeId: unknown): readonly unknown[];
     getNodeCycleEdgeIds(nodeId: unknown): readonly unknown[];
+    getNodeAdjacentEdgeIds(nodeId: unknown): readonly unknown[];
 }
 
-export declare interface PublicViewportTransformer {
+export declare class PublicViewportTransformer {
+    private readonly transformer;
+    constructor(transformer: ViewportTransformer);
     getViewportMatrix(): TransformState;
     getContentMatrix(): TransformState;
 }
@@ -595,13 +687,13 @@ export declare class UserDraggableNodesCanvas implements Canvas {
     private readonly dragCursor;
     constructor(canvas: Canvas, dragOptions?: DragOptions);
     addNode(request: AddNodeRequest): UserDraggableNodesCanvas;
-    updateNode(nodeId: unknown, request: UpdateNodeRequest): UserDraggableNodesCanvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): UserDraggableNodesCanvas;
     removeNode(nodeId: unknown): UserDraggableNodesCanvas;
     markPort(port: MarkPortRequest): UserDraggableNodesCanvas;
     updatePort(portId: string, request?: UpdatePortRequest): UserDraggableNodesCanvas;
     unmarkPort(portId: string): UserDraggableNodesCanvas;
     addEdge(edge: AddEdgeRequest): UserDraggableNodesCanvas;
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest): UserDraggableNodesCanvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): UserDraggableNodesCanvas;
     removeEdge(edgeId: unknown): UserDraggableNodesCanvas;
     patchViewportMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
     patchContentMatrix(request: PatchMatrixRequest): UserDraggableNodesCanvas;
@@ -642,13 +734,13 @@ export declare class UserTransformableCanvas implements Canvas {
     private readonly shiftCursor;
     constructor(canvas: Canvas, options?: TransformOptions | undefined);
     addNode(node: AddNodeRequest): UserTransformableCanvas;
-    updateNode(nodeId: unknown, request: UpdateNodeRequest): UserTransformableCanvas;
+    updateNode(nodeId: unknown, request?: UpdateNodeRequest): UserTransformableCanvas;
     removeNode(nodeId: unknown): UserTransformableCanvas;
     markPort(port: MarkPortRequest): UserTransformableCanvas;
-    updatePort(portId: string, request: UpdatePortRequest): UserTransformableCanvas;
+    updatePort(portId: string, request?: UpdatePortRequest): UserTransformableCanvas;
     unmarkPort(portId: string): UserTransformableCanvas;
     addEdge(edge: AddEdgeRequest): UserTransformableCanvas;
-    updateEdge(edgeId: unknown, request: UpdateEdgeRequest): UserTransformableCanvas;
+    updateEdge(edgeId: unknown, request?: UpdateEdgeRequest): UserTransformableCanvas;
     removeEdge(edgeId: unknown): UserTransformableCanvas;
     patchViewportMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
     patchContentMatrix(request: PatchMatrixRequest): UserTransformableCanvas;
@@ -695,4 +787,13 @@ declare interface VerticalEdgeShape_2 {
     readonly detourDirection?: number;
 }
 
+declare class ViewportTransformer {
+    private viewportMatrix;
+    private contentMatrix;
+    getViewportMatrix(): TransformState;
+    getContentMatrix(): TransformState;
+    patchViewportMatrix(matrix: PatchTransformRequest): void;
+    patchContentMatrix(matrix: PatchTransformRequest): void;
+}
+
 export { }