@focus.matters/diagrams 0.0.7

package/dist/Diagrams/store/extensions/NodesConnector.d.ts

@@ -0,0 +1,27 @@
+import { MouseEvent as RMEv } from 'react';
+import { Coordinates } from '../primitives/Coordinates';
+import { Gateway } from '../elements/Gateway';
+import { DiagramExtension } from './DiagramExtension';
+import { DMouseMoveEvent } from '../elements/Events';
+import { GridSnap } from './GridSnap';
+export declare class NodesConnector extends DiagramExtension {
+    protected hasRoutedPreview: boolean;
+    protected previewRequestVersion: number;
+    protected previewRafId: number | null;
+    init(): void;
+    protected arrowTo: Coordinates | null;
+    protected startGateway: Gateway | null;
+    candidateGateway: Gateway | null;
+    protected _arrowSteps: Coordinates[];
+    get arrowSteps(): Coordinates[];
+    protected get snap(): GridSnap;
+    protected calculateArrowSteps(): void;
+    protected orthogonalMousePreview(startGateway: Gateway, mouseOnPlane: Coordinates): Coordinates[];
+    protected compactPreviewPoints(points: Coordinates[]): Coordinates[];
+    protected cancelScheduledPreview(): void;
+    protected scheduleCalculateArrowSteps(): void;
+    protected u: () => void;
+    startConnectionFrom(gateway: Gateway, ev: RMEv): void;
+    protected handleMouseMove(ev: DMouseMoveEvent): void;
+    protected handleMouseUp(): void;
+}

package/dist/Diagrams/store/extensions/NodesResizer.d.ts

@@ -0,0 +1,4 @@
+import { DiagramExtension } from './DiagramExtension';
+export declare class NodesResizer extends DiagramExtension {
+    init(): void;
+}

package/dist/Diagrams/store/extensions/PathFindingRenderer.d.ts

@@ -0,0 +1,9 @@
+import { DiagramExtension } from './DiagramExtension';
+import { PathsGrid, PathGridEdge, PathGridPoint } from '../../util/paths/PathsGrid';
+export declare class PathFindingRenderer extends DiagramExtension {
+    grid: PathsGrid | null;
+    points: PathGridPoint[] | null;
+    highlighted: Set<PathGridEdge>;
+    init(): void;
+    setGrid(grid: PathsGrid | null, points: PathGridPoint[]): void;
+}

package/dist/Diagrams/store/extensions/Priorities.d.ts

@@ -0,0 +1,26 @@
+export declare class Priorities {
+    Canvas_Rules: number;
+    Change_History: number;
+    Click_Node: number;
+    Drag_Rules: number;
+    Drag_Node_Distances_Balancer: number;
+    Drag_Node_Straight_Drag: number;
+    Drag_Node_Aligner: number;
+    Drag_Node_Snap_To_Grid: number;
+    Drag_Edge_Snap_To_Grid: number;
+    Mouse_Down_Rules: number;
+    Mouse_Down_Measurer: number;
+    Mouse_Down_Selector: number;
+    Mouse_Down_Node: number;
+    Mouse_Down_Dragger: number;
+    Mouse_Move_Straight_Drag: number;
+    Mouse_Move_Selector: number;
+    Mouse_Up_Straight_Drag: number;
+    Mouse_Up_Dragger: number;
+    Mouse_Up_Selector: number;
+    Nodes_Connection_Rules: number;
+    Node_Selection_Nodes_Resizer: number;
+    Node_Selection_Selector: number;
+    Scale_Dragger: number;
+    Selection_Rules: number;
+}

package/dist/Diagrams/store/extensions/Rules.d.ts

@@ -0,0 +1,11 @@
+import { Diagram } from '../Diagram';
+export declare class Rules {
+    protected d: Diagram;
+    allowEdition: boolean;
+    allowSelection: boolean;
+    allowZoom: boolean;
+    displaceWhenDragOnEdges: boolean;
+    toggleGrid: boolean;
+    constructor(d: Diagram);
+    private check;
+}

package/dist/Diagrams/store/extensions/Selector.d.ts

@@ -0,0 +1,50 @@
+import { Dimensions } from '../primitives/Dimensions';
+import { DMouseDownEvent, DMouseUpEvent, DMouseMoveEvent } from '../elements/Events';
+import { Node } from '../elements/Node';
+import { DiagramExtension } from './DiagramExtension';
+import { Edge } from '../elements/Edge';
+type SelectionMode = 'area' | 'element';
+/**
+ * The selection must be handled entirelly by the Selector class.
+ *
+ * There are some considerations:
+ *
+ * ## The Selector has two modes
+ *
+ *  - Area selection mode:
+      When this mode is enabled, a mouse down and drag action implies selecting
+      all nodes in the dragged area.
+
+      When this mode is enabled, the event is stopped so the dragger wont be able
+      to drag the node.
+
+    - Single item selection mode:
+      When this mode is enabled, a mouse down event over a node will trigger its
+      selection.
+ */
+export declare class Selector extends DiagramExtension {
+    selectionMode: SelectionMode;
+    private _selection;
+    private _edgesSelection;
+    /**
+     * Used to draw the selection rectangle
+     */
+    private endPoint;
+    private startPoint;
+    copy(): string;
+    init(): void;
+    toggleSelectionMode(sm?: SelectionMode): void;
+    get selectedNodes(): Node<import('../types').TOrientation>[];
+    get selectedEdges(): Edge[];
+    get box(): Dimensions;
+    clearSelection(check?: (n: Node<any>) => boolean): void;
+    selectEdge(e: Edge): void;
+    selectNode(n: Node<any>): void;
+    unselectEdge(e: Edge): void;
+    unselectNode(n: Node<any>): void;
+    unbind: () => void;
+    handleMouseDown: (ev: DMouseDownEvent) => void;
+    handleMouseMove: (_ev: DMouseMoveEvent) => void;
+    handleMouseUp: (_ev: DMouseUpEvent) => void;
+}
+export {};

package/dist/Diagrams/store/extensions/StraightDrag.d.ts

@@ -0,0 +1,8 @@
+import { DiagramExtension } from './DiagramExtension';
+export declare class StraightDrag extends DiagramExtension {
+    private straight;
+    private startCoordinates;
+    private startProposals;
+    private reset;
+    init(): void;
+}

package/dist/Diagrams/store/primitives/Coordinates.d.ts

@@ -0,0 +1,45 @@
+import { Dimensions } from './Dimensions';
+import { TOrientation } from '../types';
+import { DirectedPoint } from './DirectedPoint';
+import { AnyMouseEvent, DDragEvent, DMouseEvent } from '../elements/Events';
+export interface TDirectedPoint {
+    x: number;
+    y: number;
+    direction: TOrientation;
+}
+export declare class Coordinates {
+    protected _data: number[];
+    constructor(items?: DMouseEvent | DDragEvent | AnyMouseEvent | Event | Coordinates | number[], isObservable?: boolean);
+    bound(boundaries: Dimensions): this;
+    get abs(): Coordinates;
+    assign(another: Coordinates | [number, number]): this;
+    copy(observable?: boolean): Coordinates;
+    distance(another: Coordinates): number;
+    distanceManhattan(another: Coordinates): number;
+    divide(factor: number | Coordinates): this;
+    equals(another: Coordinates): boolean;
+    get(i: number): number;
+    get length(): number;
+    max(n: number): Coordinates;
+    get nonObserved(): Coordinates;
+    get raw(): [number, number];
+    get round(): Coordinates;
+    get half(): Coordinates;
+    get norm(): number;
+    get style(): {
+        left: number;
+        top: number;
+    };
+    multiply(factor: number | Coordinates): this;
+    set(i: number, value: number): this;
+    snapToGrid(gridSize: number, dimension?: 'x' | 'y' | 'both'): this;
+    substract(another: Coordinates | [number, number]): this;
+    sum(another: Coordinates | [number, number] | number): this;
+    toDirectedPoint(direction: TOrientation): DirectedPoint;
+    toDimensions(size: Coordinates): Dimensions;
+    get x(): number;
+    get y(): number;
+    set x(value: number);
+    set y(value: number);
+    toString(): string;
+}

package/dist/Diagrams/store/primitives/Dimensions.d.ts

@@ -0,0 +1,58 @@
+import { Coordinates } from './Coordinates';
+/**
+ * [ x, y, width, height ]
+ */
+export declare class Dimensions {
+    protected _data: number[];
+    constructor(items?: Dimensions | number[], observable?: boolean);
+    get coordinates(): Coordinates;
+    get bottomLeft(): Coordinates;
+    get bottomMiddle(): Coordinates;
+    get bottomRight(): Coordinates;
+    get leftMiddle(): Coordinates;
+    get middle(): Coordinates;
+    get rightMiddle(): Coordinates;
+    get topLeft(): Coordinates;
+    get topMiddle(): Coordinates;
+    get topRight(): Coordinates;
+    get size(): Coordinates;
+    get x(): number;
+    get y(): number;
+    get height(): number;
+    get width(): number;
+    set x(value: number);
+    set y(value: number);
+    set height(value: number);
+    set width(value: number);
+    /**
+     * Diagonal norm
+     */
+    get norm(): number;
+    get length(): number;
+    get raw(): [number, number, number, number];
+    get round(): Dimensions;
+    get style(): {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    };
+    assign(this: Dimensions, another: Dimensions | [number, number, number, number]): Dimensions;
+    assignCoordinates(this: Dimensions, another: Coordinates | [number, number]): Dimensions;
+    assignDimensions(this: Dimensions, another: Coordinates | [number, number]): Dimensions;
+    bound(boundaries: Dimensions): void;
+    collides(another: Dimensions | Coordinates, detectBorders?: boolean): boolean;
+    copy(): Dimensions;
+    divide(this: Dimensions, factor: number): Dimensions;
+    edgeDistanceX(another: Dimensions): number;
+    edgeDistanceY(another: Dimensions): number;
+    get(i: number): number;
+    inflate(size: number): Dimensions;
+    multiply(this: Dimensions, factor: number): Dimensions;
+    scale(another: Coordinates): this;
+    set(i: number, value: number): void;
+    substract(this: Dimensions, another: Dimensions | [number, number, number, number]): Dimensions;
+    sum(this: Dimensions, another: Dimensions | [number, number, number, number] | Coordinates): Dimensions;
+    toString(): string;
+    translate(another: Coordinates): this;
+}

package/dist/Diagrams/store/primitives/DirectedPoint.d.ts

@@ -0,0 +1,12 @@
+import { TOrientation } from '../types';
+import { Coordinates } from './Coordinates';
+export declare class DirectedPoint extends Coordinates {
+    direction: TOrientation;
+    get rawDirectedPoint(): {
+        x: number;
+        y: number;
+        direction: TOrientation;
+    };
+    stepBack(): this;
+    stepForward(): this;
+}

package/dist/Diagrams/store/types.d.ts

@@ -0,0 +1,61 @@
+import { Dimensions } from './primitives/Dimensions';
+import { Coordinates } from './primitives/Coordinates';
+import { Gateway } from './elements/Gateway';
+import { Edge } from './elements/Edge';
+import { EdgePoint } from './elements/EdgePoint';
+export type TNodeState = {
+    id: string;
+    box: Dimensions;
+    label: string;
+} & Partial<{
+    fill: string;
+    labelFontSize: number;
+    movable: boolean;
+    selectable: boolean;
+    selected: boolean;
+    stroke: string;
+    strokewWidth: number;
+    hover: boolean;
+    zIndex: number;
+    groupChildren: boolean;
+}>;
+export type EdgePathType = 'straight' | 'curved' | 'angle';
+export type EdgeArrowHead = 'none' | 'arrow' | 'triangle' | 'triangle-filled' | 'diamond' | 'circle-small' | 'circle-medium' | 'measure';
+export type EdgeLineStyle = 'solid' | 'dashed' | 'dotted';
+export type TEdgeState = {
+    dragging: boolean;
+    hover: boolean;
+    selected: boolean;
+    label: string;
+    labelPositioning: Coordinates;
+    from: Gateway;
+    to: Gateway;
+    steps: EdgePoint[];
+} & Partial<{
+    arrowHeadEnd: EdgeArrowHead;
+    arrowHeadStart: EdgeArrowHead;
+    displacementEnd: Coordinates;
+    displacementStart: Coordinates;
+    lineStyle: EdgeLineStyle;
+    pathType: EdgePathType;
+    stroke: string;
+    strokeWidth: number;
+}>;
+export type TGatewayState = {
+    id: string;
+    allowDisplace: boolean;
+    incomingEdges: Edge[];
+    outgoingEdges: Edge[];
+    maxIncomingConnections: number;
+    maxOutgoingConnections: number;
+    orientation: TOrientation;
+    fill?: string;
+    stroke?: string;
+    strokeWidth: number;
+    radius: number;
+    /**
+     * From 0 to 1, telling the percentage of width and height of its parent
+     */
+    position: Coordinates;
+};
+export type TOrientation = 'up' | 'right' | 'down' | 'left';

package/dist/Diagrams/util/ClassList.d.ts

@@ -0,0 +1,8 @@
+export declare class ClassList {
+    private _data;
+    constructor();
+    add(...cl: string[]): void;
+    delete(cl: string): void;
+    toggle(cl: string): void;
+    get string(): string;
+}

package/dist/Diagrams/util/Mouse.d.ts

@@ -0,0 +1,9 @@
+import { Coordinates } from '../store/primitives/Coordinates';
+export declare class Mouse {
+    private static instance;
+    static getInstance(): Mouse;
+    x: number;
+    y: number;
+    get coordinates(): Coordinates;
+    constructor();
+}

package/dist/Diagrams/util/Mutex.d.ts

@@ -0,0 +1,5 @@
+import { Semaphore } from './Semaphore';
+export declare class Mutex extends Semaphore {
+    constructor();
+    runExclusive<T>(cb: () => Promise<T>): Promise<T | undefined>;
+}

package/dist/Diagrams/util/PriorityQueue.d.ts

@@ -0,0 +1,19 @@
+export declare class PriorityQueue<T extends {
+    priority: number;
+}> {
+    private heap;
+    get size(): number;
+    isEmpty(): boolean;
+    /**
+     * Returns the most prioritary element without removing it.
+     */
+    peek(): T | undefined;
+    push(item: T): void;
+    /**
+     * Removes the most prioritary element and returns it.
+     */
+    pop(): T | undefined;
+    private bubbleUp;
+    private bubbleDown;
+    private swap;
+}

package/dist/Diagrams/util/Semaphore.d.ts

@@ -0,0 +1,37 @@
+export declare class CancellablePromise<T> extends Promise<T> {
+    cancel: () => unknown;
+    constructor(executor: (resolve: (value: T) => void, reject: (reason?: any) => void) => void, cancel: () => unknown);
+}
+export declare const cancellingToken: unique symbol;
+/**
+ * A simple semaphore implementation to control concurrency.
+ * Limits the number of concurrent tasks that can run simultaneously.
+ */
+export declare class Semaphore {
+    private concurrency;
+    private current;
+    private queue;
+    /**
+     * Creates a new instance of the Semaphore.
+     *
+     * @param concurrency - The maximum number of concurrent tasks allowed.
+     */
+    constructor(concurrency: number);
+    get isBusy(): boolean;
+    /**
+     * Acquires a permit to run a task.
+     *
+     * If the number of currently acquired permits is less than the concurrency limit,
+     * the promise resolves immediately. Otherwise, it is queued until a permit is released.
+     *
+     * @returns A promise that resolves when the permit has been acquired.
+     */
+    acquire(): Promise<void>;
+    clear(): void;
+    /**
+     * Releases a previously acquired permit.
+     *
+     * If there are queued tasks waiting for a permit, the next one is dequeued and allowed to proceed.
+     */
+    release(): void;
+}

package/dist/Diagrams/util/TasksQueue.d.ts

@@ -0,0 +1,7 @@
+export type Task<T> = () => Promise<T>;
+export declare class TasksQueue {
+    private mutex;
+    get isBusy(): boolean;
+    clear(): void;
+    run<T>(task: Task<T>): Promise<T | undefined>;
+}

package/dist/Diagrams/util/arrayOrArray.d.ts

@@ -0,0 +1 @@
+export declare function arrayOrArray<T>(c: T | T[]): T[];

package/dist/Diagrams/util/awaitTime.d.ts

@@ -0,0 +1 @@
+export declare function awaitTime(ms: number): Promise<void>;

package/dist/Diagrams/util/binders.d.ts

@@ -0,0 +1,17 @@
+import { DEvent } from '../store/elements/Events';
+import { Callback as EvCB, AbstractClass } from '../store/elements/Element';
+import { Diagram } from '../store/Diagram';
+import { THotKey } from '../store/extensions/Hotkeys';
+type Callback = () => void;
+type Unsubscriber = Callback;
+export declare function bindDiagram<X extends DEvent>(target: {
+    diagram: Diagram;
+}, type: AbstractClass<X>, cb: EvCB<X>, priority?: number): () => void;
+export declare function bindHotkey(target: {
+    diagram: Diagram;
+}, hotkey: THotKey): () => void;
+export declare function bindDocument<K extends keyof DocumentEventMap>(target: any, type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): Unsubscriber;
+export declare function bindInterval(cb: Callback, time: number): () => void;
+export declare function bindTimeout(cb: Callback, time: number): () => void;
+export declare function bind(...uns: Callback[]): () => void;
+export {};

package/dist/Diagrams/util/bpmn/applyBPMNImportPlan.d.ts

@@ -0,0 +1,3 @@
+import { Diagram } from '../../store/Diagram';
+import { BPMNApplyImportResult, BPMNImportPlan } from './types';
+export declare function applyBPMNImportPlan(diagram: Diagram, plan: BPMNImportPlan): BPMNApplyImportResult;

package/dist/Diagrams/util/bpmn/buildBPMNImportPlan.d.ts

@@ -0,0 +1,3 @@
+import { BPMNImportPlan, ParsedBPMNModel } from './types';
+export declare function sanitizeId(raw: string, fallbackPrefix: string): string;
+export declare function buildBPMNImportPlan(parsed: ParsedBPMNModel): BPMNImportPlan;

package/dist/Diagrams/util/bpmn/importBPMNXmlIntoDiagram.d.ts

@@ -0,0 +1,6 @@
+import { Diagram } from '../../store/Diagram';
+import { BPMNImportSummary } from './types';
+export declare function importBPMNXmlIntoDiagram(diagram: Diagram, xml: string, _fileName?: string): {
+    warnings: string[];
+    summary: BPMNImportSummary;
+};

package/dist/Diagrams/util/bpmn/index.d.ts

@@ -0,0 +1,5 @@
+export { applyBPMNImportPlan } from './applyBPMNImportPlan';
+export { buildBPMNImportPlan, sanitizeId } from './buildBPMNImportPlan';
+export { importBPMNXmlIntoDiagram } from './importBPMNXmlIntoDiagram';
+export { parseBPMNXml } from './parseBPMNXml';
+export type * from './types';

package/dist/Diagrams/util/bpmn/parseBPMNXml.d.ts

@@ -0,0 +1,2 @@
+import { ParsedBPMNModel } from './types';
+export declare function parseBPMNXml(xml: string): ParsedBPMNModel;

package/dist/Diagrams/util/bpmn/types.d.ts

@@ -0,0 +1,103 @@
+import { TOrientation } from '../../store/types';
+export type BPMNBounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type BPMNWaypoint = {
+    x: number;
+    y: number;
+};
+export type ParsedBPMNFlowNode = {
+    id: string;
+    name: string;
+    type: string;
+    processId: string;
+};
+export type ParsedBPMNSequenceFlow = {
+    id: string;
+    name: string;
+    sourceRef: string;
+    targetRef: string;
+    processId: string;
+};
+export type ParsedBPMNLane = {
+    id: string;
+    name: string;
+    flowNodeRefs: string[];
+    processId: string;
+};
+export type ParsedBPMNProcess = {
+    id: string;
+    name: string;
+    flowNodes: ParsedBPMNFlowNode[];
+    sequenceFlows: ParsedBPMNSequenceFlow[];
+    lanes: ParsedBPMNLane[];
+};
+export type ParsedBPMNParticipant = {
+    id: string;
+    name: string;
+    processRef: string;
+};
+export type ParsedBPMNUnsupportedLink = {
+    id: string;
+    sourceRef: string;
+    targetRef: string;
+    type: string;
+};
+export type ParsedBPMNModel = {
+    processes: ParsedBPMNProcess[];
+    participants: ParsedBPMNParticipant[];
+    shapes: Map<string, BPMNBounds>;
+    edges: Map<string, BPMNWaypoint[]>;
+    unsupportedLinks: ParsedBPMNUnsupportedLink[];
+    warnings: string[];
+};
+export type BPMNNodeClassName = 'TaskNode' | 'EventNode' | 'GateNode' | 'UnknownBPMNNode';
+export type BPMNImportLanePlan = {
+    id: string;
+    processId: string;
+    participantId: string | null;
+    box: BPMNBounds;
+    poolLabels: string[];
+};
+export type BPMNImportNodePlan = {
+    bpmnId: string;
+    processId: string;
+    id: string;
+    label: string;
+    className: BPMNNodeClassName;
+    box: BPMNBounds;
+    laneIndex: number;
+    bpmnType: string;
+    eventType?: number;
+    gateType?: number;
+    sourceType?: string;
+};
+export type BPMNImportEdgePlan = {
+    bpmnId: string;
+    processId: string;
+    fromBpmnId: string;
+    toBpmnId: string;
+    fromNodeId: string;
+    toNodeId: string;
+    fromOrientation: TOrientation;
+    toOrientation: TOrientation;
+    waypoints: BPMNWaypoint[] | null;
+};
+export type BPMNImportPlan = {
+    lanes: BPMNImportLanePlan[];
+    nodes: BPMNImportNodePlan[];
+    edges: BPMNImportEdgePlan[];
+    warnings: string[];
+};
+export type BPMNImportSummary = {
+    nodes: number;
+    edges: number;
+    lanes: number;
+};
+export type BPMNApplyImportResult = {
+    summary: BPMNImportSummary;
+    warnings: string[];
+};

package/dist/Diagrams/util/cloneDeep.d.ts

@@ -0,0 +1 @@
+export declare function cloneDeep<T>(o: T): T;

package/dist/Diagrams/util/downloadFile.d.ts

@@ -0,0 +1 @@
+export declare function downloadFile(content: string, filename: string, mimeType?: string): void;

package/dist/Diagrams/util/getEnumStr.d.ts

@@ -0,0 +1,3 @@
+type EnumType = Record<string, any>;
+export declare function getEnumStr(theEnum: EnumType, index: number): string;
+export {};

package/dist/Diagrams/util/getIdForNode.d.ts

@@ -0,0 +1,2 @@
+import { Diagram } from '../store/Diagram';
+export declare function getIdForNode(diagram: Diagram, prefix: string, restrict?: string[]): string;

package/dist/Diagrams/util/getUniqueId.d.ts

@@ -0,0 +1 @@
+export declare function getUniqueId(prefix: string): string;

package/dist/Diagrams/util/insertSorted.d.ts

@@ -0,0 +1 @@
+export declare function insertSorted<T>(arr: T[], value: T, cmp: (a: T, b: T) => number): void;

package/dist/Diagrams/util/paths/PathsGrid.d.ts

@@ -0,0 +1,43 @@
+import { Coordinates } from '../../store/primitives/Coordinates';
+import { Dimensions } from '../../store/primitives/Dimensions';
+import { TOrientation } from '../../store/types';
+export declare class PathGridEdge {
+    from: PathGridPoint;
+    to: PathGridPoint;
+    constructor(from: PathGridPoint, to: PathGridPoint);
+    collides(box: Dimensions): boolean;
+    norm(): number;
+    toString(): string;
+}
+export declare class PathGridPoint extends Coordinates {
+    protected grid: PathsGrid;
+    constructor(grid: PathsGrid, data: [number, number]);
+    get x(): number;
+    get y(): number;
+}
+export declare class PathsGrid {
+    private collideDetect;
+    private _points;
+    private _edges;
+    private edgesFrom;
+    private edgesTo;
+    constructor(collideDetect: Dimensions[]);
+    add(x?: number, y?: number): PathGridPoint | undefined;
+    connect(a?: PathGridPoint, b?: PathGridPoint, force?: boolean): void;
+    createPoint(c: Coordinates): PathGridPoint;
+    getEdgesFrom(p: PathGridPoint): PathGridEdge[];
+    getEdgesTo(p: PathGridPoint): PathGridEdge[];
+    getNeighbors(p: PathGridPoint): PathGridEdge[];
+    removeInRadio(center: Coordinates, distance: number): void;
+    removeColliding(except: Dimensions[]): void;
+    private buildPath;
+    run(start: {
+        coordinates: Coordinates;
+        orientation: TOrientation;
+    }, end: {
+        coordinates: Coordinates;
+        orientation: TOrientation;
+    }): PathGridPoint[] | null;
+    get edges(): PathGridEdge[];
+    get points(): PathGridPoint[];
+}

package/dist/Diagrams/util/paths/findBestPathBetweenNodes.d.ts

@@ -0,0 +1,8 @@
+import { Diagram } from '../../store/Diagram';
+import { Gateway } from '../../store/elements/Gateway';
+import { Coordinates } from '../../store/primitives/Coordinates';
+export type Path = {
+    x: number;
+    y: number;
+}[];
+export declare function findBestPathBetweenNodes(diagram: Diagram, from: Gateway, to: Gateway, fromDisplacement?: Coordinates, toDisplacement?: Coordinates): Coordinates[];

package/dist/Diagrams/util/paths/orthogonalRouter.d.ts

@@ -0,0 +1,7 @@
+import { Diagram } from '../../store/Diagram';
+import { Edge } from '../../store/elements/Edge';
+import { EdgePoint } from '../../store/elements/EdgePoint';
+import { Gateway } from '../../store/elements/Gateway';
+import { Coordinates } from '../../store/primitives/Coordinates';
+export declare function routeOrthogonalBetweenGateways(diagram: Diagram, from: Gateway, to: Gateway, fromDisplacement?: Coordinates, toDisplacement?: Coordinates, parent?: Edge | null): EdgePoint[];
+export declare function routeOrthogonalEdge(diagram: Diagram, edge: Edge, keepManualPoints?: EdgePoint[], manualPointOverride?: EdgePoint[]): EdgePoint[];