@focus.matters/diagrams 0.0.9 → 0.1.0

package/dist/src/Diagrams/custom/bpmn/nodes/TaskNode.d.ts

@@ -0,0 +1,114 @@
+import { Diagram } from '../../../store/Diagram';
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNResizableNode } from '../extensions/BPMNNodeResizer';
+import { BPMNode } from './BPMNode';
+export declare enum TaskTypes {
+    task = 0,
+    service = 1,
+    callActivity = 2,
+    subprocess = 3,
+    send = 4,
+    receive = 5,
+    script = 6,
+    manual = 7,
+    eventSubprocess = 8,
+    businessRule = 9
+}
+export type TaskMultiInstance = "none" | "parallel";
+type TTaskNodeState = TNodeConstructorProps & {
+    type?: TaskTypes;
+    multiInstance?: TaskMultiInstance;
+    loop?: boolean;
+};
+/** Models BPMN activities with compact default geometry and selectable task variants. */
+export declare class TaskNode extends BPMNode implements BPMNResizableNode {
+    type: TaskTypes;
+    readonly minimumResizeSize: Coordinates;
+    multiInstance: TaskMultiInstance;
+    loop: boolean;
+    edgesAsGateways: boolean;
+    constructor(parent: Element | null, state: TTaskNodeState);
+    private fitWidthToGrid;
+    private applySubprocessState;
+    /** Attaches the activity and enforces its three-column active-grid width. */
+    setDiagram(diagram: Diagram): void;
+    /** Changes the semantic task variant while preserving geometry and connections. */
+    setType(type: TaskTypes): boolean;
+    /** Changes the supported multi-instance marker while preserving task type. */
+    setMultiInstance(multiInstance: TaskMultiInstance): boolean;
+    /** Toggles the standard conditional-loop marker independently of other markers. */
+    setLoop(loop: boolean): boolean;
+    /** Serializes the task subtype together with the shared editable node state. */
+    serialize(): {
+        type: TaskTypes;
+        multiInstance: TaskMultiInstance;
+        loop: boolean;
+        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: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/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;
+    };
+    /** Restores persisted task variants and defaults missing marker state safely. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
+    protected get screenLabelBox(): Dimensions;
+    RenderScreen: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}
+export {};

package/dist/{Diagrams/custom/bpmn/nodes/EventNode.d.ts → src/Diagrams/custom/bpmn/nodes/TextAnnotationNode.d.ts}

@@ -1,20 +1,17 @@
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
 import { BPMNode } from './BPMNode';
-export declare enum EventTypes {
-    start = 0,
-    end = 1,
-    intermediate = 2
-}
-export type TEventNodeType = EventTypes;
-export declare class EventNode extends BPMNode {
-    type: TEventNodeType;
-    constructor(parent: Element | null, state: TNodeConstructorProps & {
-        type?: TEventNodeType;
-    });
-    setType(type: TEventNodeType): void;
+/** Models non-executable explanatory text associated with diagram elements. */
+export declare class TextAnnotationNode extends BPMNode {
+    edgesAsGateways: boolean;
+    requiredEdgePathType: "straight";
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    /** Computes text-driven annotation bounds capped at six configured grid units. */
+    get box(): Dimensions;
+    /** Persists the computed annotation size rather than its original minimum box. */
     serialize(): {
-        type: EventTypes;
         box: [number, number, number, number];
         id: string;
         label: string;
@@ -35,7 +32,25 @@ export declare class EventNode extends BPMNode {
                 displacementEnd: [number, number] | undefined;
                 displacementStart: [number, number] | undefined;
                 lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
-                pathType: import('../../../store/types').EdgePathType | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
                 steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
                 stroke: string | undefined;
                 strokeWidth: number | undefined;
@@ -47,12 +62,14 @@ export declare class EventNode extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;
     };
-    deserialize(o: ReturnType<this['serialize']>): void;
-    protected Render: (() => import("react").JSX.Element) & {
+    /** Resolves automatic associations at the exact boundary facing the other node. */
+    findAutomaticGatewayAnchor(towards: Coordinates): import('../../../store/routers/EdgesRouter').EdgeRouterAnchor;
+    RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }

package/dist/{Diagrams → src/Diagrams}/custom/bpmn/nodes/UnknownBPMNNode.d.ts

@@ -28,7 +28,25 @@ export declare class UnknownBPMNNode extends BPMNode {
                 displacementEnd: [number, number] | undefined;
                 displacementStart: [number, number] | undefined;
                 lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
-                pathType: import('../../../store/types').EdgePathType | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
                 steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
                 stroke: string | undefined;
                 strokeWidth: number | undefined;
@@ -40,12 +58,13 @@ export declare class UnknownBPMNNode extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;
     };
-    deserialize(o: ReturnType<this['serialize']>): void;
-    protected Render: (() => import("react").JSX.Element) & {
+    deserialize(o: ReturnType<this["serialize"]>): void;
+    RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }

package/dist/src/Diagrams/custom/bpmn/ui/BPMNDiagramControls.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNModelerExtension } from '../extensions/BPMNModelerExtension';
+/** Renders selection toolbars projected beside BPMN nodes and routed edges. */
+export declare const BPMNDiagramControls: (({ diagram, extension }: TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element | null) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/bpmn/ui/BPMNElementMenu.d.ts

@@ -0,0 +1,11 @@
+import { BPMNElementDefinition, BPMNElementId } from '../config/BPMNElementCatalog';
+import { BPMNLabels } from '../config/BPMNLabels';
+type BPMNElementMenuProps = {
+    items: BPMNElementDefinition[];
+    labels: BPMNLabels;
+    onSelect: (item: BPMNElementDefinition) => void;
+    selectedId?: BPMNElementId;
+};
+/** Renders the compact catalog list shared by toolbars and transformation menus. */
+export declare function BPMNElementMenu({ items, labels, onSelect, selectedId, }: BPMNElementMenuProps): import("react").JSX.Element;
+export {};

package/dist/src/Diagrams/custom/bpmn/ui/BPMNIcon.d.ts

@@ -0,0 +1,9 @@
+export type BPMNIconId = "task" | "serviceTask" | "sendTask" | "receiveTask" | "scriptTask" | "manualTask" | "businessRuleTask" | "callActivity" | "subprocess" | "eventSubprocess" | "event" | "start" | "intermediate" | "end" | "timer" | "message" | "messageCatch" | "messageThrow" | "signal" | "compensation" | "error" | "conditional" | "terminate" | "exclusive" | "inclusive" | "parallel" | "eventBased" | "lanes" | "blackBoxPool" | "dataStore" | "document" | "documentAnnotation" | "textAnnotation" | "transform" | "connect" | "settings";
+type BPMNIconProps = {
+    id: BPMNIconId;
+    className?: string;
+    markerOnly?: boolean;
+};
+/** Draws tree-shaken Phosphor icons plus exact markers unique to BPMN notation. */
+export declare function BPMNIcon({ id, className, markerOnly }: BPMNIconProps): import("react").JSX.Element;
+export {};

package/dist/src/Diagrams/custom/bpmn/ui/BPMNPropertiesPanel.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNModelerExtension } from '../extensions/BPMNModelerExtension';
+/** Renders the animated fixed inspector for the single selected BPMN element. */
+export declare const BPMNPropertiesPanel: (({ diagram, extension }: TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/bpmn/ui/BPMNResizeHandle.d.ts

@@ -0,0 +1,7 @@
+import { BPMNResizableNode } from '../extensions/BPMNNodeResizer';
+type BPMNResizeHandleProps = {
+    node: BPMNResizableNode;
+};
+/** Renders eight screen-layer handles above connection hit targets for resize. */
+export declare function BPMNResizeHandle({ node }: BPMNResizeHandleProps): import("react").JSX.Element | null;
+export {};

package/dist/src/Diagrams/custom/bpmn/ui/resolveToolbarMenuPlacement.d.ts

@@ -0,0 +1,18 @@
+type Rectangle = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+};
+type Viewport = {
+    height: number;
+    width: number;
+};
+/** Places a submenu inside the viewport while avoiding the global floating toolbar. */
+export declare function resolveToolbarMenuPlacement(group: Rectangle, menu: Pick<Rectangle, "height" | "width">, viewport: Viewport, floatingToolbar?: Rectangle): {
+    left: boolean;
+    top: number;
+};
+export {};

package/dist/src/Diagrams/custom/bpmn/ui/resolveVisibleEdgeToolbarAnchor.d.ts

@@ -0,0 +1,4 @@
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+/** Anchors an edge toolbar near the visible viewport center instead of its origin. */
+export declare function resolveVisibleEdgeToolbarAnchor(points: Coordinates[], viewport: Dimensions, margin: number): Coordinates;

package/dist/src/Diagrams/custom/communication/edges/CommunicationEdge.d.ts

@@ -0,0 +1,9 @@
+import { Edge } from '../../../store/elements/Edge';
+import { Element } from '../../../store/elements/Element';
+import { TEdgeState } from '../../../store/types';
+type CommunicationEdgeState = Partial<TEdgeState>;
+/** Applies communication-diagram styling on top of shared editable edge state. */
+export declare class CommunicationEdge extends Edge {
+    constructor(parent: Element | null, state: CommunicationEdgeState);
+}
+export {};

package/dist/{Diagrams → src/Diagrams}/custom/communication/nodes/CommunicationActorNode.d.ts

@@ -4,7 +4,7 @@ import { CommunicationNode } from '../CommunicationNode';
 export declare class CommunicationActorNode extends CommunicationNode {
     readonly communicationNodeType: "actor";
     constructor(parent: Element | null, state: TNodeConstructorProps);
-    protected Render: (() => import("react").JSX.Element) & {
+    RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }

package/dist/{Diagrams → src/Diagrams}/custom/communication/nodes/CommunicationControllerNode.d.ts

@@ -4,7 +4,7 @@ import { CommunicationNode } from '../CommunicationNode';
 export declare class CommunicationControllerNode extends CommunicationNode {
     readonly communicationNodeType: "controller";
     constructor(parent: Element | null, state: TNodeConstructorProps);
-    protected Render: (() => import("react").JSX.Element) & {
+    RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }

package/dist/{Diagrams → src/Diagrams}/custom/communication/nodes/CommunicationObjectNode.d.ts

@@ -4,7 +4,7 @@ import { CommunicationNode } from '../CommunicationNode';
 export declare class CommunicationObjectNode extends CommunicationNode {
     readonly communicationNodeType: "object";
     constructor(parent: Element | null, state: TNodeConstructorProps);
-    protected Render: (() => import("react").JSX.Element) & {
+    RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }

package/dist/src/Diagrams/custom/communication/types.d.ts

@@ -0,0 +1 @@
+export type CommunicationNodeType = "actor" | "object" | "controller";

package/dist/src/Diagrams/custom/editable/EditableLabel.d.ts

@@ -0,0 +1,8 @@
+import { Dimensions } from '../../store/primitives/Dimensions';
+import { EditableNode } from './EditableNode';
+export declare const EditableLabel: (({ node, box }: {
+    node: EditableNode;
+    box: Dimensions;
+}) => import("react").JSX.Element | null) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/editable/EditableNode.d.ts

@@ -0,0 +1,21 @@
+import { FC } from 'react';
+import { Element } from '../../store/elements/Element';
+import { Node, TNodeConstructorProps } from '../../store/elements/Node';
+/** Provides editable node labels while preserving the pending edit for confirmation or cancellation. */
+export declare abstract class EditableNode extends Node {
+    editionMode: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    get label(): string;
+    private previous;
+    /** Starts a label editing session and saves the current value for a possible cancellation. */
+    edit(): void;
+    /** Restores the saved label value and closes the active editing session without emitting changes. */
+    cancel(): void;
+    /** Confirms the edit unless an event listener cancels it, then returns whether it was accepted. */
+    confirm(): boolean;
+    get isChanged(): boolean;
+    protected get screenLabelBox(): import('../../store/primitives/Dimensions').Dimensions;
+    /** Returns the current label bounds so surrounding controls can avoid its rendered area. */
+    get labelScreenBox(): import('../../store/primitives/Dimensions').Dimensions;
+    RenderScreen: FC<any>;
+}

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

@@ -1,15 +1,17 @@
-import { Coordinates } from './primitives/Coordinates';
-import { Dimensions } from './primitives/Dimensions';
 import { Diagram } from './Diagram';
 import { Element } from './elements/Element';
+import { Coordinates } from './primitives/Coordinates';
+import { Dimensions } from './primitives/Dimensions';
 export type ScaleEvent = {
     previousScale: number;
     newScale: number;
     displacement: Coordinates;
 };
+/** Owns viewport scale, displacement, interaction sessions, and rendered canvas bounds. */
 export declare class Canvas extends Element {
     private unbindDocumentEvents;
     private mouseSessionStartedInFrame;
+    private centerAnimationFrame;
     protected _displacement: Coordinates;
     _scale: number;
     private gridSize;
@@ -22,19 +24,25 @@ export declare class Canvas extends Element {
     get framePosition(): Coordinates;
     get frameDimensions(): Dimensions;
     constructor(parent: Diagram);
+    /** Releases document listeners and cancels any viewport animation still in flight. */
     dispose(): void;
+    /** Marks programmatic pointer sessions as eligible for the canvas drag lifecycle. */
     markMouseSessionStartedInFrame(): void;
     get dragging(): boolean;
     protected _dragging: boolean;
     displacementStart: null | Coordinates;
     eventStart: null | Coordinates;
     protected bound(): void;
-    centerOnPoint(c: Coordinates): void;
-    /**
-     * @returns how much it displaced
-     */
+    /** Centers a world point in the viewport and optionally animates the pan. */
+    centerOnPoint(c: Coordinates, animated?: boolean): void;
+    private animateDisplacement;
+    private cancelCenterAnimation;
+    private applyDisplacement;
+    /** Applies a relative viewport displacement and returns the bounded movement used. */
     displace(c: Coordinates): Coordinates;
+    /** Replaces the viewport displacement while respecting configured canvas bounds. */
     setDisplacement(c: Coordinates): void;
+    /** Changes viewport scale around a screen-space focus point and preserves alignment. */
     setScale(newScale: number, zoomCenter?: Coordinates): void;
     /**
      * Given a pair of coordinates in the canvas, returns the matching coordinates in the screen
@@ -44,6 +52,7 @@ export declare class Canvas extends Element {
      * Given a pair of coordinates in the screen, returns the matching coordinates in the canvas
      */
     inverseFit<T extends Coordinates | Dimensions>(value: T): T;
+    /** Returns the CSS transform values representing current scale and displacement. */
     getDisplacementStyles(): {
         position: string;
         width: string;
@@ -53,6 +62,7 @@ export declare class Canvas extends Element {
         willChange: string;
     };
     protected setDisplacementStyles(element?: HTMLElement | null): void;
+    /** Updates the visual grid interval used by canvas background and snapping helpers. */
     setGridSize(gridSize: number): void;
     useRef: (el: HTMLElement | null) => void;
     private isInsideFrameFromTarget;

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

@@ -1,87 +1,122 @@
 import { ReactNode } from 'react';
 import { Canvas } from './Canvas';
-import { Node } from './elements/Node';
-import { Coordinates } from './primitives/Coordinates';
 import { Edge } from './elements/Edge';
-import { Gateway } from './elements/Gateway';
 import { Element, Class } from './elements/Element';
-import { Priorities } from './extensions/Priorities';
-import { Rules } from './extensions/Rules';
-import { DiagramExtension } from './extensions/DiagramExtension';
-import { NodesAligner } from './extensions/NodesAligner';
+import { Gateway } from './elements/Gateway';
+import { Node } from './elements/Node';
 import { Creator } from './extensions/Creator';
+import { DiagramExtension } from './extensions/DiagramExtension';
+import { DistancesBalancer } from './extensions/DistancesBalancer';
+import { Dragger } from './extensions/Dragger';
 import { EdgesDragger } from './extensions/EdgesDragger';
+import { GridSnap } from './extensions/GridSnap';
+import { History } from './extensions/History';
 import { Hotkeys } from './extensions/Hotkeys';
+import { LabelsAligner } from './extensions/LabelsAligner';
 import { Measurer } from './extensions/Measurer';
-import { Selector } from './extensions/Selector';
+import { NodesAligner } from './extensions/NodesAligner';
 import { NodesConnector } from './extensions/NodesConnector';
-import { GridSnap } from './extensions/GridSnap';
-import { StraightDrag } from './extensions/StraightDrag';
-import { DistancesBalancer } from './extensions/DistancesBalancer';
 import { NodesResizer } from './extensions/NodesResizer';
-import { History } from './extensions/History';
-import { Dragger } from './extensions/Dragger';
 import { PathFindingRenderer } from './extensions/PathFindingRenderer';
-declare const DefaultExtensions: Readonly<{
+import { Priorities } from './extensions/Priorities';
+import { Rules } from './extensions/Rules';
+import { Selector } from './extensions/Selector';
+import { StraightDrag } from './extensions/StraightDrag';
+import { StraightLabelsDrag } from './extensions/StraightLabelsDrag';
+import { Coordinates } from './primitives/Coordinates';
+import { EdgePathType, TEdgeAnchorState } from './types';
+declare const getDefaultExtensions: () => {
     Creator: typeof Creator;
     DistancesBalancer: typeof DistancesBalancer;
+    StraightDrag: typeof StraightDrag;
+    StraightLabelsDrag: typeof StraightLabelsDrag;
     Dragger: typeof Dragger;
     EdgesDragger: typeof EdgesDragger;
     GridSnap: typeof GridSnap;
     History: typeof History;
     Hotkeys: typeof Hotkeys;
+    LabelsAligner: typeof LabelsAligner;
     Measurer: typeof Measurer;
     NodesAligner: typeof NodesAligner;
     NodesConnector: typeof NodesConnector;
     NodesResizer: typeof NodesResizer;
     PathFindingRenderer: typeof PathFindingRenderer;
     Selector: typeof Selector;
-    StraightDrag: typeof StraightDrag;
-}>;
+};
 export type TDefaultExensions = {
-    [key in keyof typeof DefaultExtensions]: boolean;
+    [key in keyof ReturnType<typeof getDefaultExtensions>]: boolean;
 };
 export type TDiagramSettings = Partial<{
     extensions: TDefaultExensions;
 }>;
+/** Owns diagram elements, extensions, camera state, and application interactions. */
 export declare class Diagram extends Element {
     readonly priorities: Priorities;
     rules: Rules;
     private focusContentTimer;
     private knownClasses;
+    /** Returns the registered runtime constructor associated with a serialized class name. */
     getClass(name: string): any;
+    /** Registers a runtime constructor so persisted elements can be restored safely. */
     registerClass(clazz: any, className?: any): void;
     edgeClass: typeof Edge;
+    /** Replaces the edge constructor used for subsequently created connections. */
     setDefaultEdge(clazz: typeof Edge): void;
     protected _extensions: Map<Class<DiagramExtension>, DiagramExtension>;
     protected _nodes: Map<string, Node<import('./types').TOrientation>>;
     protected _edges: Map<string, Edge>;
+    private _hoveredNode;
     canvas: Canvas;
     constructor(settings?: TDiagramSettings);
     get edges(): Readonly<Edge[]>;
+    /** Returns registered extensions in deterministic registration order for rendering. */
+    get extensions(): ReadonlyArray<DiagramExtension>;
     get nodes(): Readonly<Node[]>;
+    /** Returns the sole node currently hovered within this diagram application. */
+    get hoveredNode(): Node<any> | null;
+    /** Atomically transfers or clears the application-level node hover owner. */
+    setNodeHover(node: Node<any>, hovered: boolean): void;
+    /** Clears the application hover owner and its mirrored node presentation flag. */
+    clearNodeHover(): void;
     private getUniqueNodeId;
+    /** Adds a node, assigns a collision-free identifier, and attaches diagram state. */
     add<T extends Node>(node: T): T;
+    /** Registers an already constructed edge with both of its endpoint gateways. */
     addEdge(edge: Edge): void;
+    /** Creates and registers a routed edge between two compatible node gateways. */
     connect(from: Gateway, to: Gateway, options?: {
         fromDisplacement?: Coordinates;
+        pathType?: EdgePathType;
+        startAnchor?: TEdgeAnchorState;
+        endAnchor?: TEdgeAnchorState;
         toDisplacement?: Coordinates;
     }): Edge;
-    connectWithEdge(from: Gateway, to: Gateway, existentEdge: Edge): Edge;
+    /** Registers an existing edge instance and synchronizes both endpoint indexes. */
+    connectWithEdge(_from: Gateway, _to: Gateway, existentEdge: Edge): Edge;
+    /** Deletes a node and disconnects every edge still attached to its gateways. */
     delete(node: Node<any>): void;
+    /** Disconnects an edge from all gateway indexes and removes diagram ownership. */
     disconnect(edge: Edge): void;
     Context: ({ children }: {
         children: ReactNode;
     }) => import("react").JSX.Element;
+    /** Returns the edge registered under the requested application identifier. */
     getEdgeById(id: string): Edge | undefined;
+    /** Returns the node registered under the requested application identifier. */
     getNodeById(id: string): Node<import('./types').TOrientation> | undefined;
     get showGrid(): boolean;
+    /** Returns the initialized extension instance for the requested constructor. */
     getExtension<T extends DiagramExtension>(e: Class<T>): T;
+    /** Instantiates and initializes one extension before exposing it to callers. */
     registerExtension(e: Class<DiagramExtension>): void;
+    /** Toggles whether the diagram grid is currently visible to the application. */
     toggleGrid(): void;
     static use: () => Diagram;
+    /** Exports the complete current diagram contract as a serialized JSON string. */
     export(): string;
+    /** Requests reset approval and removes all nodes when the operation is accepted. */
     reset(): Promise<boolean>;
+    /** Serializes camera state and every owned node into the current persistence contract. */
     serialize(): {
         position: {
             x: number;
@@ -109,7 +144,25 @@ export declare class Diagram 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: EdgePathType;
+                    startAnchor: {
+                        mode: import('./types').EdgeAnchorMode;
+                        position: [number, number] | undefined;
+                    };
+                    endAnchor: {
+                        mode: import('./types').EdgeAnchorMode;
+                        position: [number, number] | undefined;
+                    };
                     steps: import('./elements/EdgePoint').TSerializedEdgePoint[];
                     stroke: string | undefined;
                     strokeWidth: number | undefined;
@@ -121,14 +174,19 @@ export declare class Diagram extends Element {
             }[];
             fill: string | undefined;
             labelFontSize: number | undefined;
+            labelOffset: [number, number] | undefined;
             stroke: string | undefined;
             strokewWidth: number | undefined;
             class: string;
         }[];
     };
+    /** Imports serialized nodes and edges while remapping any colliding identifiers. */
     import(w: string): void;
+    /** Pastes serialized nodes near the pointer while assigning fresh identifiers. */
     paste(w: string): void;
+    /** Fits all diagram content inside the current viewport with configurable padding. */
     focusContentInViewport(padding?: number): boolean;
+    /** Retries viewport fitting while layout dimensions settle after initial rendering. */
     focusContentInViewportWithRetry(attempts?: number, delayMs?: number): void;
 }
 export {};

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

@@ -0,0 +1,5 @@
+import { DChangeEvent } from './Events';
+/** Records an editable edge-label text or position mutation in diagram history. */
+export declare class DEdgeLabelChangeEvent extends DChangeEvent {
+    protected readonly __brand: void;
+}