@focus.matters/diagrams 0.0.9 → 0.1.0

package/dist/{Diagrams → src/Diagrams}/store/extensions/EdgesDragger.d.ts

@@ -1,15 +1,18 @@
-import { Coordinates } from '../primitives/Coordinates';
 import { Midpoint } from '../../components/objects/RenderEdge';
-import { EdgePoint } from '../elements/EdgePoint';
 import { Edge } from '../elements/Edge';
-import { AnyMouseEvent, DEdgeDragStartEvent, DEdgeEndpointDragStartEvent } from '../elements/Events';
+import { EdgePoint } from '../elements/EdgePoint';
+import { DEdgeDragStartEvent, DEdgeEndpointDragStartEvent, AnyMouseEvent } from '../elements/Events';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgeRouterAnchor } from '../routers/EdgesRouter';
+import { ConnectionCandidate } from '../routers/resolveConnectionCandidate';
+import { TEdgeAnchorState } from '../types';
 import { DiagramExtension } from './DiagramExtension';
 type DragContext = {
     edge: Edge;
     midpoint: Midpoint;
     pointA: EdgePoint;
     pointB: EdgePoint;
-    movedAxis: 'x' | 'y';
+    movedAxis: "x" | "y";
     startMouseCanvas: Coordinates;
     startPointA: Coordinates;
     startPointB: Coordinates;
@@ -21,18 +24,26 @@ type DragContext = {
 };
 type EndpointDragContext = {
     edge: Edge;
-    endpoint: 'from' | 'to';
+    endpoint: "from" | "to";
+    originalStart: EdgeRouterAnchor;
+    originalEnd: EdgeRouterAnchor;
+    originalStartState: TEdgeAnchorState;
+    originalEndState: TEdgeAnchorState;
+    candidate: ConnectionCandidate | null;
 };
-type EdgeEndSide = 'from' | 'to';
+type EdgeEndSide = "from" | "to";
 type PreparedSegment = {
     pointA: EdgePoint;
     pointB: EdgePoint;
-    movedAxis: 'x' | 'y';
+    movedAxis: "x" | "y";
 };
 export declare class EdgesDragger extends DiagramExtension {
+    private readonly autopan;
     protected drag: DragContext | null;
     protected endpointDrag: EndpointDragContext | null;
     protected uns: () => void;
+    endpointDragActive: boolean;
+    endpointCandidatePoint: Coordinates | null;
     init(): void;
     protected almostEqual(a: number, b: number): boolean;
     protected pointMatches(a: Coordinates, b: Coordinates): boolean;
@@ -40,46 +51,46 @@ export declare class EdgesDragger extends DiagramExtension {
     protected pointsNear(a: Coordinates, b: Coordinates, epsilon?: number): boolean;
     protected isActivePoint(point: EdgePoint): boolean;
     protected getGridSize(): number;
-    protected orientationVector(orientation: 'up' | 'down' | 'left' | 'right'): {
+    protected orientationVector(orientation: "up" | "down" | "left" | "right"): {
         x: number;
         y: number;
     };
-    protected axisPerpendicularToGateway(orientation: 'up' | 'down' | 'left' | 'right'): 'x' | 'y';
+    protected axisPerpendicularToGateway(orientation: "up" | "down" | "left" | "right"): "x" | "y";
     protected expectedLeadPoint(edge: Edge, side: EdgeEndSide): Coordinates;
-    protected leadMatchesGatewaySide(endpoint: Coordinates, lead: Coordinates, orientation: 'up' | 'down' | 'left' | 'right'): boolean;
+    protected leadMatchesGatewaySide(endpoint: Coordinates, lead: Coordinates, orientation: "up" | "down" | "left" | "right"): boolean;
     protected endpointLeadPoint(edge: Edge, side: EdgeEndSide): Coordinates | EdgePoint;
     protected ensureEndpointLeadPoint(edge: Edge, side: EdgeEndSide): number;
     protected ensureEndpointLeads(edge: Edge): void;
     protected isProtectedLeadPoint(edge: Edge, index: number): boolean;
-    protected segmentMovedAxis(a: Coordinates, b: Coordinates): 'x' | 'y';
+    protected segmentMovedAxis(a: Coordinates, b: Coordinates): "x" | "y";
     protected segmentDirection(a: Coordinates, b: Coordinates): "horizontal" | "vertical" | null;
     protected segmentIsParallelToDraggedAxis(a: Coordinates, b: Coordinates): boolean;
-    protected perpendicularAxis(axis: 'x' | 'y'): 'x' | 'y';
-    protected pointAxis(point: Coordinates, axis: 'x' | 'y'): number;
-    protected setPointAxis(point: Coordinates, axis: 'x' | 'y', value: number): void;
-    protected crossesStaticBoundary(orientation: 'up' | 'down' | 'left' | 'right', movedAxis: 'x' | 'y', point: Coordinates, boundary: Coordinates, threshold?: number): boolean;
-    protected copyAsManual(point: EdgePoint, axis?: 'x' | 'y' | 'both'): EdgePoint;
-    protected markManual(point: EdgePoint, axis?: 'x' | 'y' | 'both'): void;
-    protected clampPointPastLead(point: EdgePoint, lead: Coordinates, orientation: 'up' | 'down' | 'left' | 'right'): void;
-    protected movedAxisMatchesOrientation(movedAxis: 'x' | 'y', orientation: 'up' | 'down' | 'left' | 'right'): boolean;
-    protected edgePointAt(edge: Edge, x: number, y: number, mode?: 'auto' | 'manual' | 'static'): EdgePoint;
-    protected guardCoordinate(edge: Edge, side: EdgeEndSide, lead: Coordinates, oppositePoint: Coordinates, perpendicularAxis: 'x' | 'y'): number;
-    protected makeGuardCorner(edge: Edge, lead: Coordinates, guardCoordinate: number, movedAxis: 'x' | 'y'): EdgePoint;
+    protected perpendicularAxis(axis: "x" | "y"): "x" | "y";
+    protected pointAxis(point: Coordinates, axis: "x" | "y"): number;
+    protected setPointAxis(point: Coordinates, axis: "x" | "y", value: number): void;
+    protected crossesStaticBoundary(orientation: "up" | "down" | "left" | "right", movedAxis: "x" | "y", point: Coordinates, boundary: Coordinates, threshold?: number): boolean;
+    protected copyAsManual(point: EdgePoint, axis?: "x" | "y" | "both"): EdgePoint;
+    protected markManual(point: EdgePoint, axis?: "x" | "y" | "both"): void;
+    protected clampPointPastLead(point: EdgePoint, lead: Coordinates, orientation: "up" | "down" | "left" | "right"): void;
+    protected movedAxisMatchesOrientation(movedAxis: "x" | "y", orientation: "up" | "down" | "left" | "right"): boolean;
+    protected edgePointAt(edge: Edge, x: number, y: number, mode?: "auto" | "manual" | "static"): EdgePoint;
+    protected guardCoordinate(edge: Edge, side: EdgeEndSide, lead: Coordinates, oppositePoint: Coordinates, perpendicularAxis: "x" | "y"): number;
+    protected makeGuardCorner(edge: Edge, lead: Coordinates, guardCoordinate: number, movedAxis: "x" | "y"): EdgePoint;
     protected insertStaticBoundaryGuard(side: EdgeEndSide): boolean;
     protected insertStaticBoundaryGuards(): boolean;
     protected clampDraggedSegmentAgainstEndpointLeads(): void;
     protected mergeDraggedSegmentWithManualNeighbors(): boolean;
-    protected rebaseDraggedEndpointFixedAxis(side: 'pointA' | 'pointB', point: EdgePoint): void;
-    protected replaceDraggedEndpointWithProtectedLeadDuplicate(side: 'pointA' | 'pointB', lead: EdgePoint, replacedIndex: number): void;
+    protected rebaseDraggedEndpointFixedAxis(side: "pointA" | "pointB", point: EdgePoint): void;
+    protected replaceDraggedEndpointWithProtectedLeadDuplicate(side: "pointA" | "pointB", lead: EdgePoint, replacedIndex: number): void;
     protected absorbCollinearSegmentsIntoDraggedSegment(): boolean;
     protected removeAdjacentDuplicates(preserveActivePoints: boolean): boolean;
-    protected coordinateAnchorForPair(a: EdgePoint, b: EdgePoint, axis: 'x' | 'y', aIndex: number): number;
+    protected coordinateAnchorForPair(a: EdgePoint, b: EdgePoint, axis: "x" | "y", aIndex: number): number;
     protected snapNearlyAlignedDraggedPairs(): boolean;
     protected chooseOrthogonalCorner(from: EdgePoint, to: EdgePoint, previous?: EdgePoint, next?: EdgePoint): EdgePoint;
     protected ensureOrthogonalAdjacency(): boolean;
     protected normalizeDraggedEdge(): boolean;
     protected finalizeDraggedEdge(): void;
-    protected prepareStraightLeadSegment(edge: Edge, movedAxis: 'x' | 'y'): {
+    protected prepareStraightLeadSegment(edge: Edge, movedAxis: "x" | "y"): {
         pointA: EdgePoint;
         pointB: EdgePoint;
         movedAxis: "x" | "y";
@@ -92,7 +103,7 @@ export declare class EdgesDragger extends DiagramExtension {
     protected restoreOriginalSteps(edge: Edge, steps: EdgePoint[]): void;
     startDrag(ev: DEdgeDragStartEvent): void;
     startEndpointDrag(ev: DEdgeEndpointDragStartEvent): void;
-    protected scheduleEndpointRecompute(): void;
+    protected restoreEndpointDrag(): void;
     protected handleEndpointMouseMove(ev: AnyMouseEvent): void;
     protected moveDraggedSegment(ev: AnyMouseEvent): void;
     protected handleMouseMove(ev: AnyMouseEvent): void;

package/dist/src/Diagrams/store/extensions/History.d.ts

@@ -0,0 +1,23 @@
+import { DiagramExtension } from './DiagramExtension';
+/** Stores bounded diagram snapshots and exposes undo and redo navigation. */
+export declare class History extends DiagramExtension {
+    private readonly windowTime;
+    private readonly maxSize;
+    private index;
+    private snapshots;
+    private draggingNodes;
+    private avoidEvents;
+    private restoreSnapshot;
+    private clearTransientExtensions;
+    private checkpointPosition;
+    unbind: () => void;
+    private window;
+    /** Restores the next available snapshot while suppressing generated events. */
+    redo(): Promise<void> | undefined;
+    /** Restores the previous snapshot while suppressing generated change events. */
+    undo(): Promise<void> | undefined;
+    get hasNext(): boolean;
+    get hasPrevious(): boolean;
+    /** Observes diagram changes and schedules compact, bounded history snapshots. */
+    init(): void;
+}

package/dist/{Diagrams → src/Diagrams}/store/extensions/Hotkeys.d.ts

@@ -1,6 +1,6 @@
+import { Callback } from '../elements/Element';
 import { DKeyDownEvent } from '../elements/Events';
 import { DiagramExtension } from './DiagramExtension';
-import { Callback } from '../elements/Element';
 export type THotKey = Partial<{
     code: string;
     shift: boolean;
@@ -9,6 +9,7 @@ export type THotKey = Partial<{
 }> & {
     cb: Callback<DKeyDownEvent>;
 };
+/** Coordinates diagram keyboard shortcuts while avoiding native browser and editable-field conflicts. */
 export declare class Hotkeys extends DiagramExtension {
     hotkeys: THotKey[];
     private isEditableTarget;
@@ -16,7 +17,9 @@ export declare class Hotkeys extends DiagramExtension {
     private get measurer();
     private get selector();
     private match;
+    /** Registers diagram-level keyboard handling for editing, navigation, and export commands. */
     init(): void;
+    /** Adds one scoped keyboard shortcut and returns a cleanup callback that unregisters it. */
     register(hotkey: THotKey): () => void;
     protected revertHotkey: Map<string, () => unknown>;
 }

package/dist/src/Diagrams/store/extensions/LabelsAligner.d.ts

@@ -0,0 +1,21 @@
+import { Edge } from '../elements/Edge';
+import { EdgeLabel } from '../elements/EdgeLabel';
+import { Coordinates } from '../primitives/Coordinates';
+import { DiagramExtension } from './DiagramExtension';
+type LabelGuide = {
+    from: Coordinates;
+    id: string;
+    to: Coordinates;
+};
+/** Aligns dragged edge labels to related labels and to an optimal five-pixel route clearance. */
+export declare class LabelsAligner extends DiagramExtension {
+    proposals: LabelGuide[];
+    private readonly snapDistance;
+    /** Clears transient label-specific visual guides after a drag session is completed. */
+    clear(): void;
+    /** Initializes observable state used by the screen renderer for label alignment guides. */
+    init(): void;
+    /** Snaps one dragged label to peer labels or its edge while returning the resolved position. */
+    align(edge: Edge, label: EdgeLabel, position: Coordinates): Coordinates;
+}
+export {};

package/dist/src/Diagrams/store/extensions/NodesAligner.d.ts

@@ -0,0 +1,46 @@
+import { Node } from '../elements/Node';
+import { Dimensions } from '../primitives/Dimensions';
+import { DiagramExtension } from './DiagramExtension';
+export type AlignmentGuide = {
+    type: "v";
+    y: number;
+    range: [number, number];
+    id: string;
+} | {
+    type: "h";
+    x: number;
+    range: [number, number];
+    id: string;
+};
+type VerticalSuggestion = {
+    nodeY: number;
+    guideY: number;
+    range: [number, number];
+};
+type VerticalSuggestionProvider = (node: Node<any>, box: Dimensions) => VerticalSuggestion[];
+type HorizontalSuggestion = {
+    nodeX: number;
+    guideX: number;
+    range: [number, number];
+};
+type HorizontalSuggestionProvider = (node: Node<any>, box: Dimensions) => HorizontalSuggestion[];
+/** Applies one coherent best-fit alignment recommendation to a dragged group. */
+export declare class NodesAligner extends DiagramExtension {
+    private gridSize;
+    private horizontalSuggestionProviders;
+    private verticalSuggestionProviders;
+    proposals: AlignmentGuide[];
+    /** Registers extra horizontal candidates while preserving aligner arbitration. */
+    registerHorizontalSuggestionProvider(provider: HorizontalSuggestionProvider): () => void;
+    /** Registers extra vertical candidates while preserving aligner arbitration. */
+    registerVerticalSuggestionProvider(provider: VerticalSuggestionProvider): () => void;
+    /** Removes every transient alignment guide after a drag or modifier-key change. */
+    clear(): void;
+    /** Registers best-candidate alignment arbitration and cleanup for node dragging. */
+    init(): void;
+    private align;
+    private verticalCandidate;
+    private horizontalCandidate;
+    private applyCandidate;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { MouseEvent as RMEv } from 'react';
+import { DMouseMoveEvent } from '../elements/Events';
+import { Gateway } from '../elements/Gateway';
+import { Node } from '../elements/Node';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgeRouterAnchor } from '../routers/EdgesRouter';
+import { OrthogonalRouter } from '../routers/OrthogonalRouter';
+import { EdgePathType, TEdgeAnchorState } from '../types';
+import { DiagramExtension } from './DiagramExtension';
+import { GridSnap } from './GridSnap';
+/** Coordinates interactive edge previews, gateway resolution, and final connection. */
+export declare class NodesConnector extends DiagramExtension {
+    protected hasRoutedPreview: boolean;
+    protected previewRequestVersion: number;
+    protected previewRafId: number | null;
+    /** Declares observable connector state used by previews and interaction chrome. */
+    init(): void;
+    protected arrowTo: Coordinates | null;
+    protected startGateway: Gateway | null;
+    protected startAnchor: EdgeRouterAnchor | null;
+    protected startAnchorMode: TEdgeAnchorState["mode"];
+    protected axisConstrained: boolean;
+    candidateGateway: Gateway | null;
+    protected candidateAnchor: EdgeRouterAnchor | null;
+    protected candidateAnchorState: TEdgeAnchorState | null;
+    protected readonly previewRouter: OrthogonalRouter;
+    private pendingConnection;
+    private unbindPendingConnection;
+    protected _arrowSteps: Coordinates[];
+    get arrowSteps(): Coordinates[];
+    /** Reports the effective routing mode required by either preview endpoint. */
+    get previewPathType(): EdgePathType;
+    /** Exposes the exact candidate point used by preview and final connection. */
+    get candidatePoint(): Coordinates | null;
+    protected get snap(): GridSnap;
+    private resolveStartAnchor;
+    protected calculateArrowSteps(): void;
+    protected orthogonalMousePreview(startAnchor: EdgeRouterAnchor, mouseOnPlane: Coordinates): Coordinates[];
+    protected compactPreviewPoints(points: Coordinates[]): Coordinates[];
+    protected cancelScheduledPreview(): void;
+    protected scheduleCalculateArrowSteps(): void;
+    protected u: () => void;
+    private connectionAnchorFromEvent;
+    private handleGatewayMouseDown;
+    private handlePendingMouseMove;
+    private cancelPendingConnection;
+    /** Starts a fixed connection from the exact explicitly selected source gateway. */
+    startConnectionFrom(gateway: Gateway, ev: RMEv): void;
+    /** Starts a fixed connection from the precise clicked node boundary point. */
+    startConnectionFromNode(node: Node<any>, ev: RMEv, anchorMode?: TEdgeAnchorState["mode"]): void;
+    /** Reports whether an interactive connection preview is currently active. */
+    get connecting(): boolean;
+    private beginConnection;
+    protected handleMouseMove(ev: DMouseMoveEvent): void;
+    protected handleMouseUp(): void;
+}

package/dist/{Diagrams → src/Diagrams}/store/extensions/Priorities.d.ts

@@ -1,10 +1,11 @@
+/** Defines deterministic listener ordering so competing diagram interactions compose predictably. */
 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_Distances_Balancer: number;
     Drag_Node_Aligner: number;
     Drag_Node_Snap_To_Grid: number;
     Drag_Edge_Snap_To_Grid: number;

package/dist/{Diagrams → src/Diagrams}/store/extensions/Rules.d.ts

@@ -1,11 +1,16 @@
 import { Diagram } from '../Diagram';
+/**
+ * Controls editor interactions and persists the user's grid visibility choice.
+ */
 export declare class Rules {
     protected d: Diagram;
     allowEdition: boolean;
     allowSelection: boolean;
     allowZoom: boolean;
     displaceWhenDragOnEdges: boolean;
-    toggleGrid: boolean;
+    private _toggleGrid;
+    get toggleGrid(): boolean;
+    set toggleGrid(value: boolean);
     constructor(d: Diagram);
     private check;
 }

package/dist/{Diagrams → src/Diagrams}/store/extensions/Selector.d.ts

@@ -1,9 +1,9 @@
-import { Dimensions } from '../primitives/Dimensions';
-import { DMouseDownEvent, DMouseUpEvent, DMouseMoveEvent } from '../elements/Events';
+import { Edge } from '../elements/Edge';
+import { DMouseDownEvent, DMouseMoveEvent, DMouseUpEvent } from '../elements/Events';
 import { Node } from '../elements/Node';
+import { Dimensions } from '../primitives/Dimensions';
 import { DiagramExtension } from './DiagramExtension';
-import { Edge } from '../elements/Edge';
-type SelectionMode = 'area' | 'element';
+type SelectionMode = "area" | "element";
 /**
  * The selection must be handled entirelly by the Selector class.
  *
@@ -26,25 +26,38 @@ export declare class Selector extends DiagramExtension {
     selectionMode: SelectionMode;
     private _selection;
     private _edgesSelection;
+    private readonly autopan;
+    private pointerPoint;
     /**
      * Used to draw the selection rectangle
      */
     private endPoint;
     private startPoint;
+    /** Copies selected nodes and rewrites their internal connection identifiers. */
     copy(): string;
+    /** Registers selection event handlers and restores serialized node selection. */
     init(): void;
+    /** Switches between area and element selection using the requested mode explicitly. */
     toggleSelectionMode(sm?: SelectionMode): void;
     get selectedNodes(): Node<import('../types').TOrientation>[];
     get selectedEdges(): Edge[];
     get box(): Dimensions;
+    /** Clears every selected diagram element accepted by the supplied predicate. */
     clearSelection(check?: (n: Node<any>) => boolean): void;
+    /** Selects an edge unless a diagram selection listener cancels the request. */
     selectEdge(e: Edge): void;
+    /** Selects a selectable node unless a listener cancels the selection request. */
     selectNode(n: Node<any>): void;
+    /** Unselects an edge unless a diagram listener cancels the state transition. */
     unselectEdge(e: Edge): void;
+    /** Unselects an eligible node unless a listener cancels the state transition. */
     unselectNode(n: Node<any>): void;
     unbind: () => void;
     handleMouseDown: (ev: DMouseDownEvent) => void;
-    handleMouseMove: (_ev: DMouseMoveEvent) => void;
+    private bindEmptyCanvasGesture;
+    handleMouseMove: (ev: DMouseMoveEvent) => void;
+    private handleSelectionInterval;
+    private updateAreaSelection;
     handleMouseUp: (_ev: DMouseUpEvent) => void;
 }
 export {};

package/dist/{Diagrams → src/Diagrams}/store/extensions/StraightDrag.d.ts

@@ -1,8 +1,11 @@
 import { DiagramExtension } from './DiagramExtension';
+/** Constrains node drags to one axis whenever Shift is active before or during the gesture. */
 export declare class StraightDrag extends DiagramExtension {
     private straight;
     private startCoordinates;
     private startProposals;
+    private shiftHeld;
     private reset;
+    /** Registers modifier and pointer listeners that determine and apply the constrained axis. */
     init(): void;
 }

package/dist/src/Diagrams/store/extensions/StraightLabelsDrag.d.ts

@@ -0,0 +1,10 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { DiagramExtension } from './DiagramExtension';
+/** Constrains edge-label dragging to its dominant axis whenever Shift is currently active. */
+export declare class StraightLabelsDrag extends DiagramExtension {
+    private shiftHeld;
+    /** Tracks the Shift modifier globally so pointer-driven label timers share its current state. */
+    init(): void;
+    /** Locks the minor axis using the raw drag direction while preserving the proposed major axis. */
+    constrain(origin: Coordinates, position: Coordinates, direction?: Coordinates): Coordinates;
+}

package/dist/src/Diagrams/store/extensions/nodePositionProposalRanking.d.ts

@@ -0,0 +1,8 @@
+import { NodePositionProposal } from '../elements/Events';
+type Axis = "x" | "y";
+/** Tracks which group member first earned a high-priority movement recommendation. */
+export declare const nodePositionProposalRanking: {
+    mark(proposal: NodePositionProposal, axis: Axis): void;
+    get(proposal: NodePositionProposal, axis: Axis): number | undefined;
+};
+export {};

package/dist/{Diagrams → src/Diagrams}/store/primitives/Coordinates.d.ts

@@ -32,7 +32,7 @@ export declare class Coordinates {
     };
     multiply(factor: number | Coordinates): this;
     set(i: number, value: number): this;
-    snapToGrid(gridSize: number, dimension?: 'x' | 'y' | 'both'): 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;

package/dist/src/Diagrams/store/routers/CurvedRouter.d.ts

@@ -0,0 +1,13 @@
+import { Diagram } from '../Diagram';
+import { Edge } from '../elements/Edge';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgesRouter, EdgeRouterAnchor } from './EdgesRouter';
+/** Resolves curve endpoints while leaving cubic control geometry to rendering. */
+export declare class CurvedRouter extends EdgesRouter {
+    /** Chooses the nearest declared source gateway facing the curve destination. */
+    findAutomaticStartPoint(edge: Edge): EdgeRouterAnchor;
+    /** Chooses the nearest declared target gateway facing the curve source node. */
+    findAutomaticEndPoint(edge: Edge): EdgeRouterAnchor;
+    /** Supplies curve endpoints while SVG rendering derives cubic control points. */
+    findRoute(_diagram: Diagram, _edge: Edge, start: EdgeRouterAnchor, end: EdgeRouterAnchor): Coordinates[];
+}

package/dist/src/Diagrams/store/routers/EdgesRouter.d.ts

@@ -0,0 +1,21 @@
+import { Diagram } from '../Diagram';
+import { Edge } from '../elements/Edge';
+import { Gateway } from '../elements/Gateway';
+import { Coordinates } from '../primitives/Coordinates';
+export type EdgeRouterAnchor = {
+    gateway: Gateway;
+    point: Coordinates;
+    relativePosition: Coordinates;
+    displacement: Coordinates;
+};
+/** Defines endpoint resolution and route generation for one edge path family. */
+export declare abstract class EdgesRouter {
+    /** Selects the most suitable source boundary point for an automatic edge. */
+    abstract findAutomaticStartPoint(edge: Edge): EdgeRouterAnchor;
+    /** Selects the most suitable target boundary point for an automatic edge. */
+    abstract findAutomaticEndPoint(edge: Edge): EdgeRouterAnchor;
+    /** Calculates route points after both endpoint anchors have been resolved. */
+    abstract findRoute(diagram: Diagram, edge: Edge, start: EdgeRouterAnchor, end: EdgeRouterAnchor): Coordinates[];
+    /** Resolves local automatic anchors, attaches them, and calculates the route. */
+    route(diagram: Diagram, edge: Edge): Coordinates[];
+}

package/dist/src/Diagrams/store/routers/OrthogonalRouter.d.ts

@@ -0,0 +1,16 @@
+import { Diagram } from '../Diagram';
+import { Edge } from '../elements/Edge';
+import { Gateway } from '../elements/Gateway';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgesRouter, EdgeRouterAnchor } from './EdgesRouter';
+/** Adapts obstacle-aware orthogonal routing to the shared router contract. */
+export declare class OrthogonalRouter extends EdgesRouter {
+    /** Chooses the nearest declared source gateway facing the current target node. */
+    findAutomaticStartPoint(edge: Edge): EdgeRouterAnchor;
+    /** Chooses the nearest declared target gateway facing the current source node. */
+    findAutomaticEndPoint(edge: Edge): EdgeRouterAnchor;
+    /** Delegates route construction while preserving every manual orthogonal constraint. */
+    findRoute(diagram: Diagram, edge: Edge, _start: EdgeRouterAnchor, _end: EdgeRouterAnchor): Coordinates[];
+    /** Routes a transient preview without requiring a persisted Edge instance. */
+    findRouteBetween(diagram: Diagram, from: Gateway, to: Gateway, fromDisplacement?: Coordinates, toDisplacement?: Coordinates): Coordinates[];
+}

package/dist/src/Diagrams/store/routers/StraightRouter.d.ts

@@ -0,0 +1,13 @@
+import { Diagram } from '../Diagram';
+import { Edge } from '../elements/Edge';
+import { Coordinates } from '../primitives/Coordinates';
+import { EdgesRouter, EdgeRouterAnchor } from './EdgesRouter';
+/** Resolves boundary anchors and draws the shortest direct segment between them. */
+export declare class StraightRouter extends EdgesRouter {
+    /** Chooses the source boundary intersection on the center-to-center line. */
+    findAutomaticStartPoint(edge: Edge): EdgeRouterAnchor;
+    /** Chooses the target boundary intersection on the center-to-center line. */
+    findAutomaticEndPoint(edge: Edge): EdgeRouterAnchor;
+    /** Produces a direct route between the two fully resolved endpoint anchors. */
+    findRoute(_diagram: Diagram, _edge: Edge, start: EdgeRouterAnchor, end: EdgeRouterAnchor): Coordinates[];
+}

package/dist/src/Diagrams/store/routers/cardinalAxisConstraint.d.ts

@@ -0,0 +1,7 @@
+import { Coordinates } from '../primitives/Coordinates';
+/** Projects a dragged point onto the nearest horizontal or vertical cardinal axis. */
+export declare function cardinalAxisConstraint(origin: Coordinates, point: Coordinates): {
+    axis: "horizontal" | "vertical";
+    origin: Coordinates;
+    point: Coordinates;
+};

package/dist/src/Diagrams/store/routers/getEdgesRouter.d.ts

@@ -0,0 +1,4 @@
+import { EdgePathType } from '../types';
+import { EdgesRouter } from './EdgesRouter';
+/** Returns the shared router instance corresponding to one persisted edge type. */
+export declare function getEdgesRouter(pathType: EdgePathType): EdgesRouter;

package/dist/src/Diagrams/store/routers/resolveConnectionCandidate.d.ts

@@ -0,0 +1,22 @@
+import { Diagram } from '../Diagram';
+import { Node } from '../elements/Node';
+import { Coordinates } from '../primitives/Coordinates';
+import { TEdgeAnchorState } from '../types';
+import { EdgeRouterAnchor } from './EdgesRouter';
+export type ConnectionCandidate = {
+    anchor: EdgeRouterAnchor;
+    anchorState: TEdgeAnchorState;
+    node: Node<any>;
+    snappedToGateway: boolean;
+};
+type CandidateOptions = {
+    axisConstraint?: {
+        axis: "horizontal" | "vertical";
+        origin: Coordinates;
+    };
+    excludeNode?: Node<any>;
+    oppositePoint: Coordinates;
+};
+/** Resolves a cursor using gateway snap, exact boundary, then a declared gateway. */
+export declare function resolveConnectionCandidate(diagram: Diagram, point: Coordinates, options: CandidateOptions): ConnectionCandidate | null;
+export {};

package/dist/{Diagrams → src/Diagrams}/store/types.d.ts

@@ -1,8 +1,9 @@
-import { Dimensions } from './primitives/Dimensions';
-import { Coordinates } from './primitives/Coordinates';
-import { Gateway } from './elements/Gateway';
 import { Edge } from './elements/Edge';
+import { EdgeLabel } from './elements/EdgeLabel';
 import { EdgePoint } from './elements/EdgePoint';
+import { Gateway } from './elements/Gateway';
+import { Coordinates } from './primitives/Coordinates';
+import { Dimensions } from './primitives/Dimensions';
 export type TNodeState = {
     id: string;
     box: Dimensions;
@@ -10,6 +11,7 @@ export type TNodeState = {
 } & Partial<{
     fill: string;
     labelFontSize: number;
+    labelOffset: [number, number];
     movable: boolean;
     selectable: boolean;
     selected: boolean;
@@ -19,25 +21,32 @@ export type TNodeState = {
     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 EdgePathType = "orthogonal" | "straight" | "curved";
+export type EdgeAnchorMode = "automatic" | "fixed";
+export type TEdgeAnchorState = {
+    mode: EdgeAnchorMode;
+    position?: Coordinates;
+};
+export type EdgeArrowHead = "none" | "arrow" | "arrow-open" | "triangle" | "triangle-filled" | "diamond" | "circle-small" | "circle-medium" | "default-flow" | "measure";
+export type EdgeLineStyle = "solid" | "dashed" | "dotted";
 export type TEdgeState = {
     dragging: boolean;
     hover: boolean;
     selected: boolean;
-    label: string;
-    labelPositioning: Coordinates;
+    labels: EdgeLabel[];
     from: Gateway;
     to: Gateway;
     steps: EdgePoint[];
 } & Partial<{
+    arrowSize: number;
     arrowHeadEnd: EdgeArrowHead;
     arrowHeadStart: EdgeArrowHead;
     displacementEnd: Coordinates;
     displacementStart: Coordinates;
+    endAnchor: TEdgeAnchorState;
     lineStyle: EdgeLineStyle;
     pathType: EdgePathType;
+    startAnchor: TEdgeAnchorState;
     stroke: string;
     strokeWidth: number;
 }>;
@@ -58,4 +67,4 @@ export type TGatewayState = {
      */
     position: Coordinates;
 };
-export type TOrientation = 'up' | 'right' | 'down' | 'left';
+export type TOrientation = "up" | "right" | "down" | "left";

package/dist/src/Diagrams/util/Autopan.d.ts

@@ -0,0 +1,14 @@
+import { Diagram } from '../store/Diagram';
+import { Coordinates } from '../store/primitives/Coordinates';
+/**
+ * Displaces a diagram viewport while an interaction remains near its edges.
+ */
+export declare class Autopan {
+    private readonly diagram;
+    static readonly edgeThreshold = 100;
+    constructor(diagram: Diagram);
+    /** Applies one auto-pan step for the supplied viewport pointer coordinates. */
+    displace(pointer: Coordinates): Coordinates;
+    private axisDisplacement;
+    private step;
+}

package/dist/{Diagrams → src/Diagrams}/util/bpmn/applyBPMNImportPlan.d.ts

@@ -1,3 +1,4 @@
 import { Diagram } from '../../store/Diagram';
 import { BPMNApplyImportResult, BPMNImportPlan } from './types';
+/** Applies one prepared BPMN import plan and reports the imported element totals. */
 export declare function applyBPMNImportPlan(diagram: Diagram, plan: BPMNImportPlan): BPMNApplyImportResult;