@bpmnkit/core 0.0.23 → 0.0.24

package/dist/bpmn/auto-layout.js

@@ -4,136 +4,9 @@ const POOL_HEADER = 30;
 const LANE_HEADER = 30;
 const PADDING = 20;
 const POOL_GAP = 30;
-const CHAIN_GAP = 30;
-const CHAIN_V_GAP = 20;
 const ANN_H = 50;
 const ANN_GAP = 60;
 const ANN_PADDING = 20;
-/**
- * Reposition boundary events to the bottom edge of their host task, then walk
- * each boundary event's exclusive downstream chain and place those nodes
- * horizontally to the right of the host task.  Re-routes all affected edges.
- */
-function repositionBoundaryEvents(flowElements, result) {
-    // Collect boundary events grouped by host task id
-    const boundaryMap = new Map();
-    for (const el of flowElements) {
-        if (el.type !== "boundaryEvent")
-            continue;
-        const list = boundaryMap.get(el.attachedToRef) ?? [];
-        list.push(el.id);
-        boundaryMap.set(el.attachedToRef, list);
-    }
-    if (boundaryMap.size === 0)
-        return;
-    const nodeById = new Map(result.nodes.map((n) => [n.id, n]));
-    // Build successor / predecessor maps from edges for chain walking
-    const succIds = new Map();
-    const predIds = new Map();
-    for (const edge of result.edges) {
-        const se = succIds.get(edge.sourceRef) ?? [];
-        se.push(edge.targetRef);
-        succIds.set(edge.sourceRef, se);
-        const ps = predIds.get(edge.targetRef) ?? new Set();
-        ps.add(edge.sourceRef);
-        predIds.set(edge.targetRef, ps);
-    }
-    for (const [hostId, beIds] of boundaryMap) {
-        const hostNode = nodeById.get(hostId);
-        if (!hostNode)
-            continue;
-        for (let i = 0; i < beIds.length; i++) {
-            const beId = beIds[i];
-            if (!beId)
-                continue;
-            const beNode = nodeById.get(beId);
-            if (!beNode)
-                continue;
-            const bW = beNode.bounds.width;
-            const bH = beNode.bounds.height;
-            // Place boundary event at bottom-right of host task, stacking leftward
-            const rightEdge = hostNode.bounds.x + hostNode.bounds.width;
-            beNode.bounds.x = Math.round(rightEdge - bW / 2 - i * (bW + 4));
-            beNode.bounds.y = Math.round(hostNode.bounds.y + hostNode.bounds.height - bH / 2);
-            if (beNode.labelBounds) {
-                beNode.labelBounds.x = beNode.bounds.x + Math.round(bW / 2 - beNode.labelBounds.width / 2);
-                beNode.labelBounds.y = beNode.bounds.y + bH + 4;
-            }
-            // Collect nodes exclusively reachable from this boundary event (in BFS order)
-            const chainSet = new Set([beId]);
-            const chainOrder = [];
-            const queue = [...(succIds.get(beId) ?? [])];
-            while (queue.length > 0) {
-                const id = queue.shift();
-                if (!id || chainSet.has(id))
-                    continue;
-                // Include only if every predecessor is already in the chain
-                const preds = predIds.get(id) ?? new Set();
-                if ([...preds].every((p) => chainSet.has(p))) {
-                    chainSet.add(id);
-                    chainOrder.push(id);
-                    queue.push(...(succIds.get(id) ?? []));
-                }
-            }
-            // Find tallest chain element to compute center Y below boundary event.
-            // Each boundary event's chain gets its own vertical lane to avoid overlaps.
-            let maxChainH = 0;
-            for (const id of chainOrder) {
-                const n = nodeById.get(id);
-                if (n)
-                    maxChainH = Math.max(maxChainH, n.bounds.height);
-            }
-            const laneOffset = i * (maxChainH + CHAIN_V_GAP + 10);
-            const chainCenterY = Math.round(beNode.bounds.y + bH + CHAIN_V_GAP + maxChainH / 2 + laneOffset);
-            const chainStartX = Math.max(Math.round(beNode.bounds.x + bW / 2) + CHAIN_GAP, hostNode.bounds.x + hostNode.bounds.width + CHAIN_GAP);
-            let curX = chainStartX;
-            for (const id of chainOrder) {
-                const n = nodeById.get(id);
-                if (!n)
-                    continue;
-                n.bounds.x = curX;
-                n.bounds.y = chainCenterY - Math.round(n.bounds.height / 2);
-                if (n.labelBounds) {
-                    n.labelBounds.x = n.bounds.x + Math.round(n.bounds.width / 2 - n.labelBounds.width / 2);
-                    n.labelBounds.y = n.bounds.y + n.bounds.height + 4;
-                }
-                curX += n.bounds.width + CHAIN_GAP;
-            }
-            // Re-route all edges touching the boundary event or its chain
-            for (const edge of result.edges) {
-                if (!chainSet.has(edge.sourceRef))
-                    continue;
-                const src = nodeById.get(edge.sourceRef);
-                const tgt = nodeById.get(edge.targetRef);
-                if (!src || !tgt)
-                    continue;
-                if (edge.sourceRef === beId) {
-                    // Boundary event → first chain node: route down then right
-                    const srcX = Math.round(src.bounds.x + bW / 2);
-                    const srcY = Math.round(src.bounds.y + bH);
-                    const tgtX = Math.round(tgt.bounds.x);
-                    const tgtY = Math.round(tgt.bounds.y + tgt.bounds.height / 2);
-                    edge.waypoints = [
-                        { x: srcX, y: srcY },
-                        { x: srcX, y: tgtY },
-                        { x: tgtX, y: tgtY },
-                    ];
-                }
-                else {
-                    // Within chain: straight horizontal edge
-                    const srcX = Math.round(src.bounds.x + src.bounds.width);
-                    const srcY = Math.round(src.bounds.y + src.bounds.height / 2);
-                    const tgtX = Math.round(tgt.bounds.x);
-                    const tgtY = Math.round(tgt.bounds.y + tgt.bounds.height / 2);
-                    edge.waypoints = [
-                        { x: srcX, y: srcY },
-                        { x: tgtX, y: tgtY },
-                    ];
-                }
-            }
-        }
-    }
-}
 function contentBbox(nodes, extra) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
@@ -432,11 +305,8 @@ export function applyAutoLayout(defs) {
         const participantId = processToParticipant.get(process.id);
         const lanes = process.laneSet?.lanes ?? [];
         const hasLanes = lanes.length > 0;
+        // layoutProcess now handles boundary event repositioning internally.
         const result = layoutProcess(process);
-        // Post-process boundary events: reposition each boundary event to the bottom
-        // of its host task, then walk its exclusive downstream chain and reposition
-        // those nodes horizontally to the right of the host task.
-        repositionBoundaryEvents(process.flowElements, result);
         // Re-resolve edge crossings after boundary events moved shapes
         const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
         resolveEdgeCrossings(result.edges, nodeMap);

package/dist/bpmn/bpmn-builder.d.ts

@@ -1,4 +1,4 @@
-import type { BpmnDefinitions, BpmnFlowElement, BpmnSequenceFlow } from "./bpmn-model.js";
+import type { BpmnAssociation, BpmnDefinitions, BpmnFlowElement, BpmnSequenceFlow, BpmnTextAnnotation } from "./bpmn-model.js";
 import type { RestConnectorConfig } from "./rest-connector.js";
 /** Options shared by all element methods. */
 export interface ElementOptions {
@@ -69,6 +69,8 @@ export interface UserTaskOptions {
     name?: string;
     /** Form key or form reference. */
     formId?: string;
+    /** Emit <zeebe:userTask /> to mark as a Camunda 8 native user task. */
+    zeebeUserTask?: boolean;
 }
 /** Options for creating a call activity. */
 export interface CallActivityOptions {
@@ -117,6 +119,19 @@ export interface IntermediateThrowEventOptions extends ElementOptions {
     /** Escalation code — creates an escalation throw event (aspirational). */
     escalationCode?: string;
 }
+/** Options for an end event. */
+export interface EndEventOptions extends ElementOptions {
+    /** Error code — creates an error end event. */
+    errorCode?: string;
+    /** Error reference ID. */
+    errorRef?: string;
+    /** Message name — creates a message end event. */
+    messageName?: string;
+    /** Signal name — creates a signal end event. */
+    signalName?: string;
+    /** Escalation code — creates an escalation end event. */
+    escalationCode?: string;
+}
 /** Options for a boundary event. */
 export interface BoundaryEventOptions extends ElementOptions {
     /** ID of the activity this boundary event is attached to. */
@@ -212,6 +227,11 @@ export declare class BranchBuilder {
     /** @internal – true once connectTo() has been called, meaning the branch end is already wired */
     _connected: boolean;
     /** @internal */
+    readonly _textAnnotations: BpmnTextAnnotation[];
+    /** @internal */
+    readonly _associations: BpmnAssociation[];
+    private readonly _annCounters;
+    /** @internal */
     constructor(gatewayId: string, branchName: string);
     /** Set a FEEL condition expression on this branch's outgoing sequence flow. */
     condition(expression: string): this;
@@ -225,6 +245,10 @@ export declare class BranchBuilder {
     connectTo(targetId: string): this;
     /** @internal – ID of the last element added (or the gateway if branch is empty) */
     get _lastNodeId(): string;
+    /** Attach a text annotation to the element at the current cursor position. */
+    textAnnotation(text: string): this;
+    /** Attach a text annotation to an element by explicit ID. */
+    annotate(elementId: string, text: string): this;
     serviceTask(id: string, options: ServiceTaskOptions): this;
     userTask(id: string, options?: UserTaskOptions): this;
     scriptTask(id: string, options: ScriptTaskOptions): this;
@@ -233,7 +257,7 @@ export declare class BranchBuilder {
     businessRuleTask(id: string, options?: BusinessRuleTaskOptions): this;
     callActivity(id: string, options: CallActivityOptions): this;
     startEvent(id?: string, options?: StartEventOptions): this;
-    endEvent(id?: string, options?: ElementOptions): this;
+    endEvent(id?: string, options?: EndEventOptions): this;
     intermediateThrowEvent(id?: string, options?: IntermediateThrowEventOptions): this;
     intermediateCatchEvent(id?: string, options?: IntermediateCatchEventOptions): this;
     exclusiveGateway(id: string, options?: GatewayOptions): this;
@@ -247,16 +271,37 @@ export declare class SubProcessContentBuilder {
     readonly _elements: BpmnFlowElement[];
     /** @internal */
     readonly _flows: BpmnSequenceFlow[];
+    /** @internal */
+    readonly _textAnnotations: BpmnTextAnnotation[];
+    /** @internal */
+    readonly _associations: BpmnAssociation[];
+    private readonly _annCounters;
     private lastNodeId;
+    private currentGatewayId;
+    private openBranchEnds;
     private addElement;
     startEvent(id?: string, options?: StartEventOptions): this;
-    endEvent(id?: string, options?: ElementOptions): this;
+    endEvent(id?: string, options?: EndEventOptions): this;
+    intermediateThrowEvent(id?: string, options?: IntermediateThrowEventOptions): this;
+    intermediateCatchEvent(id?: string, options?: IntermediateCatchEventOptions): this;
     serviceTask(id: string, options: ServiceTaskOptions): this;
-    userTask(id: string, options?: UserTaskOptions): this;
     scriptTask(id: string, options: ScriptTaskOptions): this;
+    userTask(id: string, options?: UserTaskOptions): this;
+    businessRuleTask(id: string, options?: BusinessRuleTaskOptions): this;
     callActivity(id: string, options: CallActivityOptions): this;
-    intermediateThrowEvent(id?: string, options?: IntermediateThrowEventOptions): this;
-    intermediateCatchEvent(id?: string, options?: IntermediateCatchEventOptions): this;
+    sendTask(id: string, options?: ElementOptions): this;
+    receiveTask(id: string, options?: ElementOptions): this;
+    exclusiveGateway(id: string, options?: GatewayOptions): this;
+    parallelGateway(id: string, options?: ElementOptions): this;
+    inclusiveGateway(id: string, options?: GatewayOptions): this;
+    eventBasedGateway(id: string, options?: ElementOptions): this;
+    /** Attach a text annotation to the element at the current cursor position. */
+    textAnnotation(text: string): this;
+    /** Attach a text annotation to an element by explicit ID. */
+    annotate(elementId: string, text: string): this;
+    branch(name: string, callback: (b: BranchBuilder) => void): this;
+    connectTo(targetId: string): this;
+    element(elementId: string): this;
 }
 /** Fluent builder for constructing BPMN processes. */
 export declare class ProcessBuilder {
@@ -268,13 +313,26 @@ export declare class ProcessBuilder {
     private readonly sequenceFlows;
     private readonly rootErrors;
     private readonly rootMessages;
+    private readonly _textAnnotations;
+    private readonly _associations;
+    private readonly _annCounters;
     private lastNodeId;
     private currentGatewayId;
     private openBranchEnds;
     private _autoLayout;
+    private _executionPlatformVersion;
+    private _serviceTaskDefaults;
     constructor(processId: string);
     /** Enable auto-layout: `build()` will run the layout engine and populate diagram interchange data. */
     withAutoLayout(): this;
+    /** Set the Camunda execution platform version stamped into the BPMN definitions. Defaults to `"8.9.0"`. */
+    executionPlatformVersion(version: string): this;
+    /** Set process-wide defaults applied to subsequently added elements. */
+    defaults(options: {
+        serviceTask?: {
+            retries?: string;
+        };
+    }): this;
     /** Set the display name for this process. */
     name(name: string): this;
     /** Set whether this process is executable. */
@@ -291,8 +349,14 @@ export declare class ProcessBuilder {
      * is completely disconnected.
      */
     addStartEvent(id?: string, options?: StartEventOptions): this;
+    /**
+     * Alias for `addStartEvent()` — begins a new disconnected parallel path.
+     *
+     * Use this for readability when modeling processes with multiple independent paths.
+     */
+    disconnectedStartEvent(id?: string, options?: StartEventOptions): this;
     /** Add an end event. */
-    endEvent(id?: string, options?: ElementOptions): this;
+    endEvent(id?: string, options?: EndEventOptions): this;
     /** Add an intermediate throw event (none, message, signal, escalation). */
     intermediateThrowEvent(id?: string, options?: IntermediateThrowEventOptions): this;
     /** Add an intermediate catch event (timer, message, signal). */
@@ -304,6 +368,15 @@ export declare class ProcessBuilder {
      * They start a new outgoing chain from the boundary event itself.
      */
     boundaryEvent(id: string, options: BoundaryEventOptions): this;
+    /**
+     * Attach a boundary event to the preceding task and build its outgoing path,
+     * then restore the builder cursor to the preceding task so the main flow continues.
+     *
+     * @param id - ID for the boundary event element.
+     * @param options - Boundary event options (without `attachedTo` — inferred from cursor).
+     * @param handler - Callback that chains elements from the boundary event.
+     */
+    withBoundary(id: string, options: Omit<BoundaryEventOptions, "attachedTo">, handler: (b: ProcessBuilder) => void): this;
     /** Add a service task with Zeebe task definition and optional IO mappings. */
     serviceTask(id: string, options: ServiceTaskOptions): this;
     /** Add a REST connector task — syntactic sugar over `serviceTask()`. */
@@ -361,21 +434,36 @@ export declare class ProcessBuilder {
     subProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: SubProcessOptions): this;
     /** Add an event sub-process (aspirational). */
     eventSubProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: ElementOptions): this;
+    /** Attach a text annotation to the element at the current cursor position. */
+    textAnnotation(text: string): this;
+    /** Attach a text annotation to any flow element by explicit ID. */
+    annotate(elementId: string, text: string): this;
     /**
      * Build the complete BPMN definitions model.
      *
      * Resolves all forward-referenced `incoming` / `outgoing` arrays and wraps
      * the process in a {@link BpmnDefinitions} ready for XML serialization.
      */
-    build(): BpmnDefinitions;
-    private buildDiagram;
-    /**
-     * Insert matching join gateways where split-gateway branches converge
-     * on a non-gateway target. BPMN best practice: every split has a join.
-     */
-    private insertJoinGateways;
-    /** Trace backward from a node to find which split gateway it belongs to. */
-    private traceBackToSplit;
+    build(options?: {
+        strict?: boolean;
+    }): BpmnDefinitions;
+    private validate;
     private addFlowElement;
 }
+/**
+ * Builder for a complete BPMN definitions document containing one or more processes.
+ * Use `Bpmn.createDiagram(id?)` to obtain an instance.
+ */
+export declare class DiagramBuilder {
+    private readonly _id;
+    private readonly _processes;
+    private readonly _errors;
+    private readonly _messages;
+    private _executionPlatformVersion;
+    constructor(id: string);
+    /** Set the Camunda execution platform version stamped into the BPMN definitions. Defaults to `"8.9.0"`. */
+    executionPlatformVersion(version: string): this;
+    process(id: string, callback: (b: ProcessBuilder) => void): this;
+    build(): BpmnDefinitions;
+}
 //# sourceMappingURL=bpmn-builder.d.ts.map