@focus.matters/diagrams 0.0.9 → 0.1.0

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNModelerExtension.d.ts

@@ -0,0 +1,97 @@
+import { MouseEvent as ReactMouseEvent } from 'react';
+import { Edge } from '../../../store/elements/Edge';
+import { Node } from '../../../store/elements/Node';
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { EdgePathType } from '../../../store/types';
+import { BPMNElementDefinition, BPMNElementId } from '../config/BPMNElementCatalog';
+import { BPMNLabelOverrides, BPMNLabels } from '../config/BPMNLabels';
+import { BPMNEdge, BPMNEdgeKind } from '../edges/BPMNEdge';
+import { EventNode, EventDirection, EventKind, EventStage } from '../nodes/EventNode';
+import { TaskNode, TaskMultiInstance } from '../nodes/TaskNode';
+/** Coordinates BPMN catalog transformations, inferred edges, and extension UI. */
+export declare class BPMNModelerExtension extends DiagramExtension {
+    dragging: boolean;
+    propertiesPanelOpen: boolean;
+    RenderDiagram: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element | null) & {
+        displayName: string;
+    };
+    RenderUI: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    private labelConfiguration;
+    /** Returns this diagram's isolated labels, or defaults for legacy probes. */
+    get labels(): BPMNLabels;
+    /** Merges label overrides into this diagram without changing global defaults. */
+    configureLabels(overrides: BPMNLabelOverrides): void;
+    /** Registers semantic edge support and guards invalid drag-created connections. */
+    init(): void;
+    /** Returns legal enabled transformations that preserve current connections. */
+    transformTargets(node: Node): BPMNElementDefinition[];
+    /** Returns transform choices in stable catalog order including the current type. */
+    shapeOptions(node: Node): BPMNElementDefinition[];
+    /** Changes a node variant through the shared catalog and emits history state. */
+    transform(node: Node, targetId: BPMNElementId): boolean;
+    /** Returns enabled target elements that form a legal outgoing BPMN connection. */
+    connectionTargets(node: Node): BPMNElementDefinition[];
+    private inferDefinitionKind;
+    /** Creates and connects a catalog node at the nearest collision-free position. */
+    appendConnected(node: Node, targetId: BPMNElementId): Node | null;
+    private nearestAvailablePosition;
+    private placementDirectionRank;
+    /** Starts an automatic outgoing connection from the toolbar of a selected node. */
+    startToolbarConnection(node: Node, event: ReactMouseEvent): void;
+    /** Reports whether the interactive connector should replace selection UI. */
+    get connecting(): boolean;
+    /** Updates a selected node label and records the mutation in diagram history. */
+    renameNode(node: Node, label: string): void;
+    private acceptsEventDefinition;
+    /** Lists event kinds available without invalidating an existing attachment. */
+    eventKindOptions(node: EventNode): EventKind[];
+    private eventDefinitionForKind;
+    /** Changes only the kind and normalizes independently unsupported dimensions. */
+    changeEventKind(node: EventNode, kind: EventKind): boolean;
+    /** Lists valid stages while preserving the independently selected direction. */
+    eventStageOptions(node: EventNode): EventStage[];
+    /** Lists valid directions while preserving the independently selected stage. */
+    eventDirectionOptions(node: EventNode): EventDirection[];
+    /** Changes an event stage without modifying the independently chosen direction. */
+    changeEventStage(node: EventNode, stage: EventStage): boolean;
+    /** Changes whether the current event catches or throws its configured trigger. */
+    changeEventDirection(node: EventNode, direction: EventDirection): boolean;
+    /** Toggles whether an attached boundary event interrupts its owning task. */
+    changeEventInterrupting(node: EventNode, interrupting: boolean): void;
+    private eventSubprocessStart;
+    private containedEventCandidate;
+    /** Returns the concrete start-event kind configured by an event subprocess. */
+    eventSubprocessStartKind(node: TaskNode): EventKind | "";
+    /** Creates or updates the movable internal start event selected on its owner. */
+    changeEventSubprocessStartKind(node: TaskNode, kind: EventKind): EventNode | null;
+    /** Changes the activity multi-instance marker while recording one property mutation. */
+    changeTaskMultiInstance(node: TaskNode, multiInstance: TaskMultiInstance): boolean;
+    /** Toggles a task's standard conditional loop and records the property change. */
+    changeTaskLoop(node: TaskNode, loop: boolean): boolean;
+    /** Updates a selected edge label and records the mutation in diagram history. */
+    renameEdge(edge: Edge, label: string): void;
+    /** Returns only edge kinds that preserve all endpoint-specific BPMN constraints. */
+    edgeKindOptions(edge: BPMNEdge): BPMNEdgeKind[];
+    /** Updates a BPMN edge kind and refreshes its visual connection convention. */
+    changeEdgeKind(edge: BPMNEdge, kind: BPMNEdgeKind): void;
+    /** Reverses one BPMN edge while retaining its route and emitting a history change. */
+    reverseEdge(edge: BPMNEdge): void;
+    /** Changes one BPMN edge routing strategy while preserving history integration. */
+    changeEdgePathType(edge: BPMNEdge, pathType: EdgePathType): void;
+    /** Updates the conditional expression associated with a sequence flow edge. */
+    changeEdgeCondition(edge: BPMNEdge, condition: string): void;
+    /** Toggles a legal gateway default while preserving source-wide exclusivity. */
+    changeEdgeDefault(edge: BPMNEdge, isDefault: boolean): boolean;
+    /** Toggles an eligible edge target marker and records the semantic history change. */
+    changeEdgeDirected(edge: BPMNEdge, isDirected: boolean): void;
+    /** Returns whether this edge can be the default of an exclusive or inclusive gateway. */
+    supportsDefaultFlow(edge: BPMNEdge): boolean;
+    /** Returns whether sequence-flow conditions are meaningful for this source. */
+    supportsCondition(edge: BPMNEdge): boolean;
+    /** Toggles the properties inspector and persists its current preference locally. */
+    togglePropertiesPanel(): void;
+    /** Closes the properties inspector and persists its disabled preference locally. */
+    closePropertiesPanel(): void;
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNNodeResizer.d.ts

@@ -0,0 +1,31 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from '../nodes/BPMNode';
+export type BPMNResizableNode = BPMNode & {
+    readonly minimumResizeSize: Coordinates;
+};
+export type BPMNResizeDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+/** Owns opt-in BPMN node resize sessions with grid, bounds, and edge updates. */
+export declare class BPMNNodeResizer extends DiagramExtension {
+    private readonly autopan;
+    private session;
+    private unbindSession;
+    /** Initializes the imperative extension consumed by resizable BPMN renderers. */
+    init(): void;
+    /** Starts a directional resize gesture safely from any side or corner handle. */
+    startResize(node: BPMNResizableNode, event: PointerEvent, direction: BPMNResizeDirection): void;
+    /** Applies a constrained size immediately and reroutes every connected edge. */
+    resizeNode(node: BPMNResizableNode, size: Coordinates | [number, number]): boolean;
+    /** Resizes from one handle while keeping the opposite sides anchored in place. */
+    resizeNodeFromDirection(node: BPMNResizableNode, initialBox: Dimensions, direction: BPMNResizeDirection, delta: Coordinates): boolean;
+    private snapDirectionalBoxToGrid;
+    private snapCoordinate;
+    private applyBox;
+    private constrain;
+    private rerouteConnectedEdges;
+    private handlePointerMove;
+    private handleAutopan;
+    private resizeFromPointer;
+    private endSession;
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNPropertyChangeEvent.d.ts

@@ -0,0 +1,4 @@
+import { DChangeEvent } from '../../../store/elements/Events';
+/** Marks inspector-driven BPMN property mutations as history-aware changes. */
+export declare class BPMNPropertyChangeEvent extends DChangeEvent {
+}

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNResizeSuggester.d.ts

@@ -0,0 +1,23 @@
+import { DiagramExtension } from '../../../store/extensions/DiagramExtension';
+import { AlignmentGuide } from '../../../store/extensions/NodesAligner';
+import { Coordinates } from '../../../store/primitives/Coordinates';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from '../nodes/BPMNode';
+import { BPMNResizeDirection } from './BPMNNodeResizer';
+/** Suggests BPMN resize stops that match peer dimensions and corresponding sides. */
+export declare class BPMNResizeSuggester extends DiagramExtension {
+    alignmentProposals: AlignmentGuide[];
+    /** Initializes the observable guide collection used by the diagram overlay. */
+    init(): void;
+    /** Removes all transient guides when a resize gesture finishes or restarts. */
+    clear(): void;
+    /** Returns the best snapped box while publishing every associated visual guide. */
+    suggest(node: BPMNode, box: Dimensions, direction: BPMNResizeDirection, fallback?: Dimensions, minimumResizeSize?: Coordinates): Dimensions;
+    private sideCandidate;
+    private widthCandidate;
+    private candidate;
+    private isValid;
+    private verticalGuide;
+    private horizontalGuide;
+    private widthGuides;
+}

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

@@ -0,0 +1,28 @@
+/** Stable compatibility codes used by persisted diagrams and catalog transforms. */
+export declare enum EventTypes {
+    start = 0,
+    end = 1,
+    intermediate = 2,
+    timer = 3,
+    messageCatch = 4,
+    messageThrow = 5,
+    signalCatch = 6,
+    signalThrow = 7,
+    compensationCatch = 8,
+    compensationThrow = 9,
+    errorCatch = 10,
+    errorThrow = 11,
+    conditional = 12,
+    terminate = 13
+}
+export type EventStage = "start" | "intermediate" | "end";
+export type EventKind = "none" | "timer" | "message" | "signal" | "compensation" | "error" | "conditional" | "terminate";
+export type EventDirection = "catch" | "throw";
+export type EventDefinition = Readonly<{
+    stage: EventStage;
+    kind: EventKind;
+    direction: EventDirection;
+}>;
+export declare const EVENT_DEFINITION_BY_TYPE: Readonly<Record<EventTypes, EventDefinition>>;
+/** Validates the complete event tuple against the supported BPMN combinations. */
+export declare function isValidEventDefinition(value: unknown): value is EventDefinition;

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

@@ -0,0 +1,15 @@
+import { Diagram } from '../../../store/Diagram';
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { EditableNode } from '../../editable/EditableNode';
+/** Provides shared BPMN sizing, typography, and connection-boundary behavior. */
+export declare abstract class BPMNode extends EditableNode {
+    edgesAsGateways: boolean;
+    protected occupiesGridSquare: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected fitToGridSquare(): void;
+    /** Attaches the node and reapplies any geometry tied to the active grid size. */
+    setDiagram(diagram: Diagram): void;
+    /** Restores shared state while enforcing current typography and grid geometry. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,17 @@
+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 an external BPMN participant whose internal process remains hidden. */
+export declare class BlackBoxPoolNode extends BPMNode implements BPMNResizableNode {
+    readonly minimumResizeSize: Coordinates;
+    edgesAsGateways: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    RenderScreen: (({ node }: TNodeScreenRenderProps<BlackBoxPoolNode>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

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

@@ -0,0 +1,14 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+import { BPMNode } from './BPMNode';
+/** Models persistent information storage used through directional BPMN associations. */
+export declare class DataStoreNode extends BPMNode {
+    requiredEdgePathType: "straight";
+    protected occupiesGridSquare: boolean;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected get screenLabelBox(): Dimensions;
+    RenderOverlay: (() => import("react").JSX.Element) & {
+        displayName: string;
+    };
+}

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

@@ -0,0 +1,130 @@
+import { Element } from '../../../store/elements/Element';
+import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Dimensions } from '../../../store/primitives/Dimensions';
+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 {
+    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;
+        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 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/{Diagrams → src/Diagrams}/custom/bpmn/nodes/GateNode.d.ts

@@ -1,5 +1,6 @@
 import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
+import { Dimensions } from '../../../store/primitives/Dimensions';
 import { BPMNode } from './BPMNode';
 export declare enum GateTypes {
     inclusive = 0,
@@ -7,12 +8,17 @@ export declare enum GateTypes {
     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];
@@ -35,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;
@@ -47,12 +71,15 @@ export declare class GateNode 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) & {
+    /** 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) & {
         displayName: string;
     };
 }

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,131 @@
+import { FC } from 'react';
+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;
+    height: number;
+    children: TPool[];
+};
+type TLaneLayout = {
+    lane: TPool;
+    depth: number;
+    y: number;
+    height: number;
+    siblingCount: number;
+};
+/**
+ * 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 = 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;
+    /** Inserts a sibling immediately before or after the referenced visible lane. */
+    insertLane(referenceId: string, position: "before" | "after"): void;
+    /** Replaces a leaf with two children while preserving its previous total height. */
+    subdivideLane(id: string): void;
+    /** Collapses all descendants back into their parent without changing total height. */
+    removeSubdivision(id: string): void;
+    /** 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): boolean;
+    /** Starts label editing for one lane through either screen or keyboard actions. */
+    renameLane(id: string): void;
+    protected editionLaneId: string | null;
+    protected previousPools: TPool[];
+    /** Restores the complete tree that existed before the current edit session. */
+    cancel(): void;
+    /** Commits labels and hierarchy changes made during the current edit session. */
+    confirm(): boolean;
+    /** Starts editing and snapshots the entire hierarchy for cancellation support. */
+    edit(): void;
+    /** Removes every root lane so importers can rebuild the hierarchy explicitly. */
+    resetPools(): void;
+    /** Restores the strictly hierarchical lane payload from serialized diagram data. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
+    /** Serializes lane dimensions and descendants together with the base node state. */
+    serialize(): {
+        pools: TPool[];
+        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;
+    };
+    RenderScreen: (({ node: lanes }: import('../../../../store/elements/Node').TNodeScreenRenderProps<Lanes>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    RenderOverlay: FC;
+}
+export {};