@focus.matters/diagrams 0.0.10 → 0.1.0

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

@@ -0,0 +1,19 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps, TNodeScreenRenderProps } from '../../../store/elements/Node';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { BPMNResizableNode } from '../extensions/BPMNNodeResizer';
+import { BPMNode } from './BPMNode';
+/** Models a resizable folded-page BPMN annotation with editable interior text. */
+export declare class DocumentAnnotationNode extends BPMNode implements BPMNResizableNode {
+    readonly minimumResizeSize: Coordinates;
+    edgesAsGateways: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    /** Resolves automatic associations against the exact facing node boundary. */
+    findAutomaticGatewayAnchor(towards: Coordinates): import('../../../store/routers/EdgesRouter').EdgeRouterAnchor;
+    RenderScreen: (({ node }: TNodeScreenRenderProps<DocumentAnnotationNode>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

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

@@ -0,0 +1,13 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from './BPMNode';
+/** Models a transient BPMN data document connected through directional associations. */
+export declare class DocumentNode extends BPMNode {
+    requiredEdgePathType: "straight";
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected get screenLabelBox(): Dimensions;
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

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

@@ -1,21 +1,66 @@
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
-import { BPMNode } from './BPMNode';
 import { Dimensions } from '../../../store/primitives/Dimensions';
-export declare enum EventTypes {
-    start = 0,
-    end = 1,
-    intermediate = 2
-}
+import { EventTypes, EventDefinition, EventDirection, EventKind, EventStage } from './BPMNEventDefinition';
+import { BPMNode } from './BPMNode';
+export { EventTypes } from './BPMNEventDefinition';
+export type { EventDefinition, EventDirection, EventKind, EventStage } from './BPMNEventDefinition';
 export type TEventNodeType = EventTypes;
+export type EventAttachmentOffset = readonly [number, number];
+type TEventNodeState = TNodeConstructorProps & {
+    type?: TEventNodeType;
+    eventDefinition?: EventDefinition;
+    attachedToTaskId?: string | null;
+    attachmentOffset?: EventAttachmentOffset | null;
+    interrupting?: boolean;
+    subprocessStart?: boolean;
+    subprocessId?: string | null;
+};
+/** Models fixed-grid BPMN events with orthogonal stage and marker semantics. */
 export declare class EventNode extends BPMNode {
-    type: TEventNodeType;
-    constructor(parent: Element | null, state: TNodeConstructorProps & {
-        type?: TEventNodeType;
-    });
-    setType(type: TEventNodeType): void;
+    definition: EventDefinition;
+    attachedToTaskId: string | null;
+    attachmentOffset: EventAttachmentOffset | null;
+    interrupting: boolean;
+    subprocessStart: boolean;
+    subprocessId: string | null;
+    edgesAsGateways: boolean;
+    protected occupiesGridSquare: boolean;
+    constructor(parent: Element | null, state: TEventNodeState);
+    get stage(): EventStage;
+    get kind(): EventKind;
+    get direction(): EventDirection;
+    get type(): TEventNodeType;
+    get isStart(): boolean;
+    get isEnd(): boolean;
+    get isCatching(): boolean;
+    /** Reports whether this event kind can be placed on an activity boundary. */
+    get canAttach(): boolean;
+    /** Reports whether this event kind can start an event-driven sub-process. */
+    get canStartSubprocess(): boolean;
+    /** Atomically changes the event tuple after validating its BPMN combination. */
+    setDefinition(definition: EventDefinition): boolean;
+    /** Applies one stable compatibility code using its canonical default tuple. */
+    setType(type: TEventNodeType): boolean;
+    /** Stores declarative boundary attachment data without performing drag behavior. */
+    setAttachment(taskId: string | null, offset?: EventAttachmentOffset | null, interrupting?: boolean): void;
+    /** Toggles boundary interruption styling without changing attachment geometry. */
+    setInterrupting(interrupting: boolean): void;
+    /** Marks this compatible event with the dashed event-subprocess start border. */
+    setSubprocessStart(subprocessStart: boolean, subprocessId?: string | null): boolean;
+    /** Serializes canonical semantics, compatibility data, and optional attachment. */
     serialize(): {
         type: EventTypes;
+        eventDefinition: Readonly<{
+            stage: EventStage;
+            kind: EventKind;
+            direction: EventDirection;
+        }>;
+        attachedToTaskId: string | null;
+        attachmentOffset: EventAttachmentOffset | null;
+        interrupting: boolean;
+        subprocessStart: boolean;
+        subprocessId: string | null;
         box: [number, number, number, number];
         id: string;
         label: string;
@@ -36,7 +81,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;
@@ -48,12 +111,19 @@ export declare class EventNode extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;
     };
+    /** Restores canonical or legacy event state and reapplies fixed-grid geometry. */
     deserialize(o: ReturnType<this["serialize"]>): void;
+    /** Remaps boundary and subprocess references during import, copy, and paste. */
+    remapSerializedReferences<T>(state: T, idMap: ReadonlyMap<string, string>): T;
     protected get screenLabelBox(): Dimensions;
+    private refreshSemanticClasses;
+    private refreshAttachmentPresentation;
+    private get markerIconId();
     RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };

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

@@ -1,19 +1,24 @@
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
-import { BPMNode } from './BPMNode';
 import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from './BPMNode';
 export declare enum GateTypes {
     inclusive = 0,
     exclusive = 1,
     parallel = 2,
     eventBased = 3
 }
+/** Models fixed-grid BPMN gateways and their mutually exclusive marker variants. */
 export declare class GateNode extends BPMNode {
     type: GateTypes;
+    edgesAsGateways: boolean;
+    protected occupiesGridSquare: boolean;
     constructor(parent: Element | null, state: TNodeConstructorProps & {
         type?: GateTypes;
     });
+    /** Changes the semantic gateway variant and its corresponding visual marker. */
     setType(type: GateTypes): void;
+    /** Serializes the gateway subtype together with common editable node state. */
     serialize(): {
         type: GateTypes;
         box: [number, number, number, number];
@@ -36,7 +41,25 @@ export declare class GateNode 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;
@@ -48,10 +71,12 @@ export declare class GateNode extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;
     };
+    /** Restores a persisted gateway subtype and reapplies current grid geometry. */
     deserialize(o: ReturnType<this["serialize"]>): void;
     protected get screenLabelBox(): Dimensions;
     RenderOverlay: (() => import("react").JSX.Element) & {

package/dist/src/Diagrams/custom/bpmn/nodes/Lanes/LaneScreenRenderer.d.ts

@@ -1,5 +1,5 @@
-import { TNodeScreenRenderProps } from '../../../../store/elements/Node';
 import { Lanes } from '.';
+import { TNodeScreenRenderProps } from '../../../../store/elements/Node';
 /** Renders crisp lane labels and contextual controls in viewport coordinates. */
 export declare const LaneScreenRenderer: (({ node: lanes }: TNodeScreenRenderProps<Lanes>) => import("react").JSX.Element) & {
     displayName: string;

package/dist/src/Diagrams/custom/bpmn/nodes/Lanes/index.d.ts

@@ -1,7 +1,8 @@
 import { FC } from 'react';
-import { BPMNode } from '../BPMNode';
+import { Diagram } from '../../../../store/Diagram';
 import { Element } from '../../../../store/elements/Element';
 import { Dimensions } from '../../../../store/primitives/Dimensions';
+import { BPMNode } from '../BPMNode';
 type TPool = {
     name: string;
     label: string;
@@ -19,19 +20,24 @@ type TLaneLayout = {
  * Models and renders a resizable hierarchy of BPMN lanes and their controls.
  */
 export declare class Lanes extends BPMNode {
+    edgesAsGateways: boolean;
+    pools: TPool[];
     static readonly laneHeaderWidth = 50;
     static readonly laneHeight = 250;
-    static readonly laneHeaderFontSize = 14;
+    static readonly laneHeaderFontSize = 16;
     static readonly minimumLaneHeight = 150;
     static readonly minimumWidthInGrids = 10;
     constructor(parent: Element | null, state: {
         id: string;
     });
+    /** Attaches the lane and enforces the current diagram grid's minimum width. */
+    setDiagram(diagram: Diagram): void;
     /** Returns bounds that exactly match the rendered lane hierarchy. */
     get box(): Dimensions;
     /** Returns every visible lane with its depth and absolute vertical geometry. */
     get laneLayouts(): TLaneLayout[];
     get editingLaneId(): string | null;
+    private get labels();
     private nextPool;
     /** Appends one root lane and returns it for existing programmatic callers. */
     addPool(): TPool;
@@ -41,10 +47,10 @@ export declare class Lanes extends BPMNode {
     subdivideLane(id: string): void;
     /** Collapses all descendants back into their parent without changing total height. */
     removeSubdivision(id: string): void;
-    /** Removes one lane only when its hierarchy level retains at least one sibling. */
+    /** Removes a lane while preserving one root lane or at least two nested lanes. */
     removeLane(id: string): void;
     /** Resizes a lane while enforcing one task box plus one grid of total padding. */
-    resizeLane(id: string, height: number, gridSize?: number): void;
+    resizeLane(id: string, height: number, gridSize?: number): boolean;
     /** Starts label editing for one lane through either screen or keyboard actions. */
     renameLane(id: string): void;
     protected editionLaneId: string | null;
@@ -82,7 +88,25 @@ export declare class Lanes 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;
@@ -94,11 +118,11 @@ export declare class Lanes extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: string;
     };
-    pools: TPool[];
     RenderScreen: (({ node: lanes }: import('../../../../store/elements/Node').TNodeScreenRenderProps<Lanes>) => import("react").JSX.Element) & {
         displayName: string;
     };

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

@@ -1,9 +1,114 @@
-import { BPMNode } from './BPMNode';
+import { Diagram } from '../../../store/Diagram';
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
-export declare class TaskNode extends BPMNode {
-    constructor(parent: Element | null, state: TNodeConstructorProps);
+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/src/Diagrams/custom/bpmn/nodes/TextAnnotationNode.d.ts

@@ -0,0 +1,75 @@
+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';
+/** 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(): {
+        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;
+    };
+    /** 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/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,6 +58,7 @@ export declare class UnknownBPMNNode extends BPMNode {
         }[];
         fill: string | undefined;
         labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
         stroke: string | undefined;
         strokewWidth: number | undefined;
         class: 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;