@focus.matters/diagrams 0.0.9 → 0.1.0

package/dist/src/Diagrams/store/elements/Edge.d.ts

@@ -0,0 +1,92 @@
+import { MouseEvent } from 'react';
+import { Midpoint } from '../../components/objects/RenderEdge';
+import { Coordinates } from '../primitives/Coordinates';
+import { Dimensions } from '../primitives/Dimensions';
+import { EdgeRouterAnchor } from '../routers/EdgesRouter';
+import { EdgePathType, TEdgeAnchorState, TEdgeState } from '../types';
+import { EdgeLabel } from './EdgeLabel';
+import { EdgePoint, TSerializedEdgePoint } from './EdgePoint';
+import { Element } from './Element';
+import { Gateway } from './Gateway';
+/** Models a routed connection, its endpoint anchors, editable label, and state. */
+export declare class Edge extends Element {
+    state: TEdgeState;
+    id: Readonly<string>;
+    constructor(parent: Element | null, state: TEdgeState);
+    get arrowHeadEnd(): import('../types').EdgeArrowHead | undefined;
+    get arrowHeadStart(): import('../types').EdgeArrowHead | undefined;
+    get from(): Gateway;
+    get hasManualSteps(): EdgePoint | undefined;
+    get lineStyle(): import('../types').EdgeLineStyle | undefined;
+    get pathType(): EdgePathType;
+    get startAnchor(): TEdgeAnchorState;
+    get endAnchor(): TEdgeAnchorState;
+    get steps(): EdgePoint[];
+    get stroke(): string | undefined;
+    get strokeWidth(): number | undefined;
+    get labels(): readonly EdgeLabel[];
+    /** Creates one independent blank label exactly at the supplied world position. */
+    createLabel(position: Coordinates): EdgeLabel;
+    /** Removes one owned label and optionally records the deletion in history. */
+    removeLabel(label: EdgeLabel, emitChange?: boolean): void;
+    /** Updates the first label used by property panels, creating it when necessary. */
+    setPrimaryLabel(text: string): EdgeLabel | null;
+    /** Finds the length-weighted route midpoint used for programmatic first labels. */
+    defaultLabelPosition(): Coordinates;
+    /** Reports whether any routed segment intersects the supplied diagram bounds. */
+    collides(box: Dimensions): boolean;
+    /** Updates one observable edge-state property through a MobX action boundary. */
+    setState<K extends keyof TEdgeState>(prop: K, value: TEdgeState[K]): void;
+    /** Replaces the route and marks both endpoint coordinates as immutable anchors. */
+    setSteps(steps: Coordinates[]): void;
+    /** Changes this edge routing strategy and immediately rebuilds its route. */
+    setPathType(pathType: EdgePathType): void;
+    /** Resolves a persisted fixed endpoint against the node's current geometry. */
+    resolveEndpointAnchor(endpoint: "from" | "to"): EdgeRouterAnchor;
+    /** Changes one endpoint between automatic and exact boundary positioning. */
+    setEndpointAnchor(endpoint: "from" | "to", anchor: TEdgeAnchorState, recompute?: boolean): void;
+    /** Reconnects one endpoint to a resolved node anchor and optionally reroutes. */
+    setResolvedEndpoint(endpoint: "from" | "to", resolved: EdgeRouterAnchor, anchor: TEdgeAnchorState, recompute?: boolean): void;
+    /** Reattaches resolved gateways safely and updates derived displacements. */
+    applyResolvedAnchors(start: EdgeRouterAnchor, end: EdgeRouterAnchor): void;
+    get to(): Gateway;
+    /** Restores the complete current edge contract and reconnects its target node. */
+    deserialize(o: ReturnType<(typeof this)["serialize"]>): void;
+    /** Serializes routing, endpoint anchors, presentation, and editable label state. */
+    serialize(): {
+        arrowHeadEnd: import('../types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../types').EdgeLineStyle | undefined;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: EdgePathType;
+        startAnchor: {
+            mode: import('../types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        steps: TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    /** Starts an orthogonal segment drag by emitting its normalized diagram event. */
+    dragStart(midpoint: Midpoint, ev: MouseEvent): void;
+    /** Starts reconnecting one endpoint while preventing duplicate pointer handling. */
+    dragEndpoint(endpoint: "from" | "to", ev: MouseEvent): void;
+}

package/dist/src/Diagrams/store/elements/EdgeLabel.d.ts

@@ -0,0 +1,64 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { Edge } from './Edge';
+import { Element } from './Element';
+type EdgeLabelState = {
+    alignment?: "left" | "center" | "right";
+    id?: string;
+    text?: string;
+    position: Coordinates;
+    size?: {
+        height: number;
+        width: number;
+    };
+};
+/** Models one independently editable and movable screen-rendered edge label. */
+export declare class EdgeLabel extends Element {
+    parent: Edge;
+    readonly id: string;
+    text: string;
+    alignment: "left" | "center" | "right";
+    size: {
+        height: number;
+        width: number;
+    };
+    position: Coordinates;
+    isEditing: boolean;
+    draft: string;
+    private isNew;
+    constructor(parent: Edge, state: EdgeLabelState, isNew?: boolean);
+    /** Replaces persisted text for programmatic editors without emitting history. */
+    setText(text: string): void;
+    /** Changes horizontal text alignment and records the presentation update in history. */
+    setAlignment(alignment: "left" | "center" | "right"): void;
+    /** Replaces the persisted world-space label box size without emitting history immediately. */
+    setSize(size: {
+        height: number;
+        width: number;
+    }): void;
+    /** Opens this label editor with a draft copied from its persisted text value. */
+    beginEdit(): void;
+    /** Updates only the transient input draft while the label remains in edition. */
+    setDraft(text: string): void;
+    /** Cancels editing and discards a newly-created label that has never persisted. */
+    cancelEdit(): void;
+    /** Removes this label and emits history only when it has already been persisted. */
+    delete(): void;
+    /** Commits edited text, removing empty labels and emitting one history change. */
+    confirmEdit(): void;
+    /** Moves this label to an absolute diagram position without changing its edge. */
+    setPosition(position: Coordinates): void;
+    /** Records the completed pointer movement as one undoable diagram mutation. */
+    commitPosition(): void;
+    /** Serializes identity, alignment, size, text, and absolute world position for persistence. */
+    serialize(): {
+        alignment: "right" | "left" | "center";
+        id: string;
+        size: {
+            height: number;
+            width: number;
+        };
+        text: string;
+        position: [number, number];
+    };
+}
+export {};

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

@@ -1,8 +1,8 @@
 import { Coordinates } from '../primitives/Coordinates';
 import { Element } from './Element';
 import { AnyMouseEvent } from './Events';
-export type TEdgePointType = 'auto' | 'manual' | 'static';
-export type TEdgePointManualAxes = 'none' | 'x' | 'y' | 'both';
+export type TEdgePointType = "auto" | "manual" | "static";
+export type TEdgePointManualAxes = "none" | "x" | "y" | "both";
 export type TSerializedEdgePoint = [number, number, TEdgePointType] | [number, number, TEdgePointType, TEdgePointManualAxes];
 export declare class EdgePoint extends Coordinates {
     parent: Element | null;
@@ -11,8 +11,8 @@ export declare class EdgePoint extends Coordinates {
     constructor(parent: Element | null, items?: AnyMouseEvent | Event | Coordinates | number[] | TSerializedEdgePoint);
     get manualX(): boolean;
     get manualY(): boolean;
-    addManualAxis(axis: 'x' | 'y' | 'both'): this;
-    hasManualAxis(axis: 'x' | 'y'): boolean;
+    addManualAxis(axis: "x" | "y" | "both"): this;
+    hasManualAxis(axis: "x" | "y"): boolean;
     markStatic(): this;
     copy(): EdgePoint;
     toString(includeMode?: boolean): string;

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

@@ -1,11 +1,11 @@
-import { MouseEvent as ME, KeyboardEvent as KE } from 'react';
-import { Element } from './Element';
+import { KeyboardEvent as KE, MouseEvent as ME } from 'react';
+import { Midpoint } from '../../components/objects/RenderEdge';
 import { Coordinates } from '../primitives/Coordinates';
-import { Node } from './Node';
 import { Edge } from './Edge';
-import { Midpoint } from '../../components/objects/RenderEdge';
-import { MouseInformation } from './EventsMouseInformation';
+import { Element } from './Element';
+import { Node } from './Node';
 import { Dimensions } from '../primitives/Dimensions';
+import { MouseInformation } from './EventsMouseInformation';
 export type AnyMouseEvent = ME | MouseEvent;
 export type AnyKeyboardEvent = KE | KeyboardEvent;
 export declare abstract class DEvent {
@@ -191,10 +191,10 @@ export declare class DEdgeDragStartEvent extends DDragEvent {
 }
 export declare class DEdgeEndpointDragStartEvent extends DDragEvent {
     src: Edge;
-    endpoint: 'from' | 'to';
+    endpoint: "from" | "to";
     originalEvent: AnyMouseEvent;
     protected readonly __brand: void;
-    constructor(src: Edge, endpoint: 'from' | 'to', originalEvent: AnyMouseEvent);
+    constructor(src: Edge, endpoint: "from" | "to", originalEvent: AnyMouseEvent);
 }
 export declare class NodePositionProposal {
     readonly node: Node<any>;
@@ -222,11 +222,11 @@ export declare class DDragNodeEvent extends DDragEvent {
 }
 export declare class EdgePointPositionProposal {
     readonly point: Coordinates;
-    readonly movedAxis: 'x' | 'y';
+    readonly movedAxis: "x" | "y";
     private _updated;
     private _lockX;
     private _lockY;
-    constructor(point: Coordinates, movedAxis: 'x' | 'y');
+    constructor(point: Coordinates, movedAxis: "x" | "y");
     get current(): Coordinates;
     get(): Coordinates;
     lockX(): void;
@@ -238,7 +238,7 @@ export declare class EdgePointPositionProposal {
 export declare class DDragEdgeSegmentEvent extends DDragEvent {
     src: Element;
     proposals: EdgePointPositionProposal[];
-    movedAxis: 'x' | 'y';
+    movedAxis: "x" | "y";
     protected readonly __brand: void;
-    constructor(src: Element, proposals: EdgePointPositionProposal[], movedAxis: 'x' | 'y', originalEvent: AnyMouseEvent);
+    constructor(src: Element, proposals: EdgePointPositionProposal[], movedAxis: "x" | "y", originalEvent: AnyMouseEvent);
 }

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

@@ -6,10 +6,12 @@ import { Element } from './Element';
 export declare class Gateway extends Element {
     parent: Node<any>;
     state: TGatewayState;
-    constructor(parent: Node<any>, state: Pick<TGatewayState, 'maxIncomingConnections' | 'maxOutgoingConnections' | 'orientation' | 'id'> & Partial<TGatewayState>);
-    addIncomingEdge(edge: Edge): void;
-    addOutgoingEdge(edge: Edge): void;
-    canConnect(from: Gateway): boolean;
+    constructor(parent: Node<any>, state: Pick<TGatewayState, "maxIncomingConnections" | "maxOutgoingConnections" | "orientation" | "id"> & Partial<TGatewayState>);
+    addIncomingEdge(edge: Edge, _recompute?: boolean): void;
+    addOutgoingEdge(edge: Edge, recompute?: boolean): void;
+    canConnect(from: Gateway, ignoreEdge?: Edge): boolean;
+    /** Checks outgoing capacity while optionally ignoring a reconnected edge. */
+    canStartConnection(to: Gateway, ignoreEdge?: Edge): boolean;
     connectionDisplacement(c: Coordinates): Coordinates;
     connectionDistance(c: Coordinates): number;
     removeIncomingEdge(edge: Edge): void;
@@ -26,10 +28,10 @@ export declare class Gateway extends Element {
     get id(): string;
     get direction(): "horizontal" | "vertical";
     get orientation(): import('../types').TOrientation;
-    recomputeConnectedEdge(edge: Edge, _movedSide: 'from' | 'to'): void;
+    recomputeConnectedEdge(edge: Edge, _movedSide: "from" | "to"): void;
     updateEdges(): void;
     get remainingSlots(): number;
-    deserialize(c: ReturnType<(typeof this)['serialize']>): void;
+    deserialize(c: ReturnType<(typeof this)["serialize"]>): void;
     serialize(): {
         coordinates: [number, number];
         fill: string | undefined;
@@ -44,7 +46,25 @@ export declare class Gateway extends Element {
             displacementEnd: [number, number] | undefined;
             displacementStart: [number, number] | undefined;
             lineStyle: import('../types').EdgeLineStyle | undefined;
-            pathType: import('../types').EdgePathType | undefined;
+            labels: {
+                alignment: "right" | "left" | "center";
+                id: string;
+                size: {
+                    height: number;
+                    width: number;
+                };
+                text: string;
+                position: [number, number];
+            }[];
+            pathType: import('../types').EdgePathType;
+            startAnchor: {
+                mode: import('../types').EdgeAnchorMode;
+                position: [number, number] | undefined;
+            };
+            endAnchor: {
+                mode: import('../types').EdgeAnchorMode;
+                position: [number, number] | undefined;
+            };
             steps: import('./EdgePoint').TSerializedEdgePoint[];
             stroke: string | undefined;
             strokeWidth: number | undefined;

package/dist/src/Diagrams/store/elements/Node.d.ts

@@ -0,0 +1,143 @@
+import { FC } from 'react';
+import { ClassList } from '../../util/ClassList';
+import { Diagram } from '../Diagram';
+import { Coordinates } from '../primitives/Coordinates';
+import { Dimensions } from '../primitives/Dimensions';
+import { EdgeRouterAnchor } from '../routers/EdgesRouter';
+import { EdgePathType, TNodeState, TOrientation } from '../types';
+import { Element } from './Element';
+import { Gateway } from './Gateway';
+type EdgeGatewayShape = "rectangle" | "ellipse" | "diamond";
+export type TNodeConstructorProps = Pick<TNodeState, "id" | "label"> & Partial<TNodeState>;
+export type TNodeRenderProps<N extends Node<any> = Node<any>> = {
+    node: N;
+    box: Dimensions;
+};
+export type TNodeScreenRenderProps<N extends Node<any> = Node<any>> = TNodeRenderProps<N> & {
+    scale: number;
+};
+/** Models a positioned diagram element with declared gateways and routed edges. */
+export declare class Node<Gateways = TOrientation> extends Element {
+    protected _gateways: Map<Gateways, Gateway>;
+    state: TNodeState;
+    readonly classList: ClassList;
+    edgesAsGateways: boolean;
+    requiredEdgePathType: EdgePathType | null;
+    protected edgeGatewayShape: EdgeGatewayShape;
+    get selected(): boolean | undefined;
+    /** Reports whether this node owns the diagram-wide hover state right now. */
+    get hovered(): boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    /** Reports whether current state and node policy allow entering selection now. */
+    canSelect(): boolean;
+    /** Reports whether the node currently participates in the active selection. */
+    canUnselect(): boolean;
+    /** Attaches this node to the diagram that owns its rendering and connections. */
+    setDiagram(d: Diagram): void;
+    /** Updates one observable node-state property through a MobX action boundary. */
+    setState<K extends keyof TNodeState>(prop: K, value: TNodeState[K]): void;
+    /** Requests or releases exclusive hover ownership through the parent diagram. */
+    setHovered(hovered: boolean): void;
+    protected initializeGateways(): void;
+    get box(): Dimensions;
+    get coordinates(): Coordinates;
+    /** Translates the node box by a canvas-space displacement without rerouting. */
+    displace(howMuch: Coordinates): void;
+    get id(): string;
+    /** Returns the persisted displacement of a movable external node label. */
+    get labelOffset(): Coordinates;
+    /** Moves an external label while keeping it within a nearby bounded region. */
+    setLabelOffset(offset: Coordinates | [number, number]): void;
+    get gateways(): Gateway[];
+    protected dragEventMouseStartPosition: Coordinates | null;
+    protected dragEventStartPosition: Coordinates | null;
+    /** Returns the gateway registered under the requested node-specific identifier. */
+    getGateway(which: Gateways): Gateway | undefined;
+    private boundaryPoint;
+    private anchorForBoundaryPoint;
+    /** Resolves a precise mouse location to the nearest valid boundary anchor. */
+    findFixedConnectionAnchor(point: Coordinates): EdgeRouterAnchor;
+    /** Finds the exact shape intersection sharing one cardinal axis with an endpoint. */
+    findAxisAlignedConnectionAnchor(oppositePoint: Coordinates, axis: "horizontal" | "vertical"): EdgeRouterAnchor | null;
+    /** Resolves the exact shape-boundary intersection facing a supplied route hint. */
+    findAutomaticConnectionAnchor(towards: Coordinates): EdgeRouterAnchor;
+    /** Selects the nearest declared perimeter gateway for automatic routed edges. */
+    findAutomaticGatewayAnchor(towards: Coordinates): EdgeRouterAnchor;
+    /** Restores a fixed relative boundary position after node movement or resize. */
+    findRelativeConnectionAnchor(position: Coordinates): EdgeRouterAnchor;
+    /** Returns whether an interior drop should let the router choose the anchor. */
+    usesAutomaticConnectionPoint(point: Coordinates): boolean;
+    /** Builds the invisible SVG boundary used to begin connections anywhere. */
+    get connectionBoundaryPath(): string;
+    /** Replaces node width and height while retaining its current canvas position. */
+    setDimentions(c: Coordinates | [number, number]): void;
+    private updateConnectedEdges;
+    /** Moves the node inside canvas bounds and optionally recomputes attached edges. */
+    setPosition(c: Coordinates, options?: {
+        updateConnectedEdges?: boolean;
+    }): void;
+    /** Restores node geometry, gateways, and outgoing edges from the current contract. */
+    deserialize(o: ReturnType<(typeof this)["serialize"]>): void;
+    /** Serializes node geometry, presentation, selection, gateways, and connections. */
+    serialize(): {
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: EdgePathType;
+                startAnchor: {
+                    mode: import('../types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('./EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Remaps node-specific serialized references when import or copy changes ids. */
+    remapSerializedReferences<T>(state: T, _idMap: ReadonlyMap<string, string>): T;
+    RenderOverlay: FC<any> | null;
+    RenderScreen: FC<any> | null;
+}
+export {};

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

@@ -1,6 +1,6 @@
 import { DClickEvent } from '../elements/Events';
 import { DiagramExtension } from './DiagramExtension';
-export type TCreationMode = 'none' | 'text';
+export type TCreationMode = "none" | "text";
 export declare class Creator extends DiagramExtension {
     creationMode: TCreationMode;
     init(): void;

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

@@ -0,0 +1,23 @@
+import { FC } from 'react';
+import { Diagram } from '../Diagram';
+import { Element } from '../elements/Element';
+export type TDiagramExtensionRenderProps<T extends DiagramExtension = DiagramExtension> = {
+    diagram: Diagram;
+    extension: T;
+};
+export declare abstract class DiagramExtension extends Element {
+    parent: Diagram;
+    constructor(parent: Diagram);
+    abstract init(): void;
+    /** Renders fixed editor chrome that remains independent from canvas panning. */
+    RenderUI: FC<TDiagramExtensionRenderProps<any>> | null;
+    /** Renders viewport-projected content that follows diagram pan and zoom state. */
+    RenderDiagram: FC<TDiagramExtensionRenderProps<any>> | null;
+    get diagram(): Diagram;
+    protected _enable: boolean;
+    get enabled(): boolean;
+    disable(): void;
+    enable(): void;
+    /** Changes the enabled state and optionally persists the user's preference. */
+    toggle(newValue?: boolean, persist?: boolean): void;
+}

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

@@ -1,13 +1,19 @@
-import { DiagramExtension } from './DiagramExtension';
 import { Coordinates } from '../primitives/Coordinates';
+import { DiagramExtension } from './DiagramExtension';
 type Proposal = {
     from: Coordinates;
     to: Coordinates;
 };
+/** Balances spacing using the best matching member of a rigid dragged group. */
 export declare class DistancesBalancer extends DiagramExtension {
     private gridSize;
     proposals: Proposal[];
+    /** Removes every transient equal-distance guide when the current drag finishes. */
     clear(): void;
+    /** Registers best-candidate equal-distance balancing for every node drag event. */
     init(): void;
+    private balance;
+    private findNeighbors;
+    private applyCandidate;
 }
 export {};

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

@@ -1,8 +1,12 @@
 import { Diagram } from '../Diagram';
+import { DMouseDownEvent, DMouseMoveEvent, DScaleEvent } from '../elements/Events';
 import { Node } from '../elements/Node';
 import { Coordinates } from '../primitives/Coordinates';
-import { DMouseDownEvent, DMouseMoveEvent, DScaleEvent } from '../elements/Events';
 import { DiagramExtension } from './DiagramExtension';
+type StartDragOptions = {
+    deferAutopanUntilSafe?: boolean;
+    startImmediately?: boolean;
+};
 /**
  * Conditions for dragging:
  *
@@ -10,14 +14,19 @@ import { DiagramExtension } from './DiagramExtension';
  * - The selection mode isn't enabled
  * - The mouse button is the left click
  */
-/**
- */
+/** Coordinates single, grouped, and rigid multi-node dragging with canvas auto-pan. */
 export declare class Dragger extends DiagramExtension {
     private dragThreshold;
+    private readonly autopan;
+    private autopanReady;
+    private dragStarted;
+    private draggingLabel;
+    private primaryNodeId;
     /**
      * childId -> parentId, built at drag start for grouped nodes.
      */
     private groupedChildren;
+    /** Registers diagram input listeners that drive node movement and drag cleanup. */
     init(): void;
     constructor(parent: Diagram);
     protected draggingNodes: Map<string, {
@@ -28,19 +37,25 @@ export declare class Dragger extends DiagramExtension {
     protected startPointScaled: Coordinates;
     protected mousePoint: Coordinates;
     protected unsubscribe: () => void;
-    startDrag(node: Node, mousePoint?: Coordinates): void;
+    /** Starts a pointer-aligned programmatic drag with optional deferred auto-pan. */
+    startDrag(node: Node, mousePoint?: Coordinates, options?: StartDragOptions): void;
     protected originalEvent: DMouseDownEvent | null;
+    private labelDragHandle;
+    private createLabelDragState;
+    private snapLabelOffset;
     protected handleMouseDown(ev: DMouseDownEvent): void;
     protected handleMouseMove(ev: DMouseMoveEvent): void;
     protected handleDragAction(): void;
-    private calcDisplacement;
     private isFullyContained;
     private collectConnectedEdges;
     private translateEdge;
     private updateEdgesAfterBatchMove;
+    private rigidSelectionDisplacement;
     private applyNodePositionProposals;
     private includeGroupedChildren;
     protected handleDragInterval(): void;
     protected handleMouseUp(): void;
+    private pointerIsInsideSafeViewport;
     protected handleScale(_ev: DScaleEvent): void;
 }
+export {};