@bpmnkit/core 0.0.26 → 0.1.0

package/dist/bpmn/auto-layout.js

@@ -1,12 +1,9 @@
+import { associationWaypoints, packAnnotations } from "../layout/annotations.js";
 import { layoutProcess } from "../layout/layout-engine.js";
-import { resolveEdgeCrossings } from "../layout/routing.js";
 const POOL_HEADER = 30;
 const LANE_HEADER = 30;
 const PADDING = 20;
 const POOL_GAP = 30;
-const ANN_H = 50;
-const ANN_GAP = 60;
-const ANN_PADDING = 20;
 function contentBbox(nodes, extra) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
@@ -34,97 +31,6 @@ function contentBbox(nodes, extra) {
     }
     return { minX, minY, maxX, maxY };
 }
-/** Pre-compute annotation positions in layout space (before dx/dy shift). */
-function computeAnnotationLocalBounds(process, layoutNodes) {
-    const nodeById = new Map(layoutNodes.map((n) => [n.id, n]));
-    const placements = new Map();
-    // Occupied regions for overlap checks (node bounds + label bounds)
-    const occupied = [];
-    for (const n of layoutNodes) {
-        occupied.push({ ...n.bounds });
-        if (n.labelBounds)
-            occupied.push({ ...n.labelBounds });
-    }
-    // Static obstacles for crossing detection (nodes + labels only, not annotations)
-    const obstacles = [...occupied];
-    for (const ta of process.textAnnotations) {
-        const assoc = process.associations.find((a) => a.sourceRef === ta.id || a.targetRef === ta.id);
-        const connId = assoc
-            ? assoc.sourceRef === ta.id
-                ? assoc.targetRef
-                : assoc.sourceRef
-            : undefined;
-        const connNode = connId ? nodeById.get(connId) : undefined;
-        const annW = Math.min(200, Math.max(100, (ta.text?.length ?? 10) * 5));
-        if (!connNode) {
-            const candidate = { x: 0, y: 0, width: annW, height: ANN_H };
-            occupied.push({ ...candidate });
-            placements.set(ta.id, candidate);
-            continue;
-        }
-        const localX = connNode.bounds.x + connNode.bounds.width / 2 - annW / 2;
-        const anchorX = connNode.bounds.x + connNode.bounds.width / 2;
-        const pushStep = ANN_H + ANN_PADDING * 2 + 10;
-        // Try below: start below connected element, push down for overlaps
-        const belowY = connNode.bounds.y + connNode.bounds.height + ANN_GAP;
-        const below = { x: localX, y: belowY, width: annW, height: ANN_H };
-        for (let i = 0; i < 30 && hasOverlapPadded(below, occupied, ANN_PADDING); i++)
-            below.y += pushStep;
-        // Try above: gap scales with text length so longer annotations have more breathing room
-        const aboveGap = ANN_GAP + Math.round(annW * 0.2);
-        const aboveY = connNode.bounds.y - aboveGap - ANN_H;
-        const above = { x: localX, y: aboveY, width: annW, height: ANN_H };
-        for (let i = 0; i < 30 && hasOverlapPadded(above, occupied, ANN_PADDING); i++)
-            above.y -= pushStep;
-        // Count how many obstacles the association line would cross for each candidate
-        const belowCrossings = countLineCrossings(anchorX, connNode.bounds, below, obstacles);
-        const aboveCrossings = countLineCrossings(anchorX, connNode.bounds, above, obstacles);
-        const candidate = belowCrossings <= aboveCrossings ? below : above;
-        occupied.push({ ...candidate });
-        obstacles.push({ ...candidate });
-        placements.set(ta.id, candidate);
-    }
-    return placements;
-}
-/** Count how many obstacles the vertical association line from connNode to annotation crosses. */
-function countLineCrossings(lineX, connBounds, annBounds, obstacles) {
-    const annCY = annBounds.y + annBounds.height / 2;
-    const connCY = connBounds.y + connBounds.height / 2;
-    const top = Math.min(annCY, connCY);
-    const bottom = Math.max(annCY, connCY);
-    const tolerance = 20;
-    let crossings = 0;
-    for (const b of obstacles) {
-        // Skip the connected element itself
-        if (b.x === connBounds.x && b.y === connBounds.y && b.width === connBounds.width)
-            continue;
-        // Obstacle must overlap with the line's X corridor
-        if (b.x + b.width < lineX - tolerance || b.x > lineX + tolerance)
-            continue;
-        // Obstacle must be between connNode and annotation vertically
-        if (b.y + b.height <= top || b.y >= bottom)
-            continue;
-        crossings++;
-    }
-    return crossings;
-}
-function hasOverlap(a, others) {
-    for (const b of others) {
-        if (a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y)
-            return true;
-    }
-    return false;
-}
-function hasOverlapPadded(a, others, padding) {
-    for (const b of others) {
-        if (a.x - padding < b.x + b.width &&
-            a.x + a.width + padding > b.x &&
-            a.y - padding < b.y + b.height &&
-            a.y + a.height + padding > b.y)
-            return true;
-    }
-    return false;
-}
 function nodeToShape(node, dx, dy) {
     const shape = {
         id: `${node.id}_di`,
@@ -201,19 +107,38 @@ function buildLaneShapes(lanes, nodes, dx, dy, poolY, poolHeaderWidth, laneConte
         const mB = accB && accB.count > 0 ? accB.sum / accB.count : Number.POSITIVE_INFINITY;
         return mA - mB;
     });
-    const tileH = Math.round(poolHeight / sortedLanes.length);
-    return sortedLanes.map((lane, i) => ({
-        id: `${lane.id}_di`,
-        bpmnElement: lane.id,
-        isHorizontal: true,
-        bounds: {
-            x: Math.round(poolHeaderWidth),
-            y: Math.round(poolY + i * tileH),
-            width: Math.round(laneContentWidth),
-            height: Math.round(i === sortedLanes.length - 1 ? poolHeight - i * tileH : tileH),
-        },
-        unknownAttributes: {},
-    }));
+    // Compute proportional weight per lane: node count × row height, minimum 1 row
+    const MIN_LANE_H = 80;
+    const weights = sortedLanes.map((lane) => {
+        const count = nodes.filter((n) => elemToLane.get(n.id) === lane.id).length;
+        return Math.max(count, 1);
+    });
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    // Scale proportionally to poolHeight so all lanes fill the pool exactly
+    const scaledHeights = weights.map((w) => Math.round((w / totalWeight) * poolHeight));
+    // Fix last lane for rounding drift
+    if (scaledHeights.length > 0) {
+        scaledHeights[scaledHeights.length - 1] =
+            poolHeight - scaledHeights.slice(0, -1).reduce((a, b) => a + b, 0);
+    }
+    let cumulativeY = 0;
+    return sortedLanes.map((lane, i) => {
+        const laneH = scaledHeights[i] ?? MIN_LANE_H;
+        const shape = {
+            id: `${lane.id}_di`,
+            bpmnElement: lane.id,
+            isHorizontal: true,
+            bounds: {
+                x: Math.round(poolHeaderWidth),
+                y: Math.round(poolY + cumulativeY),
+                width: Math.round(laneContentWidth),
+                height: Math.round(laneH),
+            },
+            unknownAttributes: {},
+        };
+        cumulativeY += laneH;
+        return shape;
+    });
 }
 function addAnnotationShapes(process, layoutNodes, annLocalBounds, allShapes, allEdges, dx, dy) {
     if (process.textAnnotations.length === 0 && process.associations.length === 0)
@@ -244,33 +169,17 @@ function addAnnotationShapes(process, layoutNodes, annLocalBounds, allShapes, al
         const elId = annId === assoc.sourceRef ? assoc.targetRef : assoc.sourceRef;
         const annB = annId ? annLocalBounds.get(annId) : undefined;
         const elNode = nodeById.get(elId);
-        if (!annB || !elNode)
+        if (!annB || !annId || !elNode)
             continue;
-        const elB = elNode.bounds;
-        const annCx = Math.round(annB.x + annB.width / 2 + dx);
-        const elCx = Math.round(elB.x + elB.width / 2 + dx);
-        let waypoints;
-        if (annB.y >= elB.y + elB.height) {
-            // annotation below: element bottom-center → annotation top-center
-            waypoints = [
-                { x: elCx, y: Math.round(elB.y + elB.height + dy) },
-                { x: annCx, y: Math.round(annB.y + dy) },
-            ];
-        }
-        else if (annB.y + annB.height <= elB.y) {
-            // annotation above: element top-center → annotation bottom-center
-            waypoints = [
-                { x: elCx, y: Math.round(elB.y + dy) },
-                { x: annCx, y: Math.round(annB.y + annB.height + dy) },
-            ];
-        }
-        else {
-            // side-by-side: center-to-center
-            waypoints = [
-                { x: Math.round(elB.x + elB.width / 2 + dx), y: Math.round(elB.y + elB.height / 2 + dy) },
-                { x: annCx, y: Math.round(annB.y + annB.height / 2 + dy) },
-            ];
-        }
+        const { pElem, pAnn } = associationWaypoints(elNode.bounds, annB);
+        // Shift into diagram space and honour the original sourceRef→targetRef order.
+        const shifted = {
+            pElem: { x: Math.round(pElem.x + dx), y: Math.round(pElem.y + dy) },
+            pAnn: { x: Math.round(pAnn.x + dx), y: Math.round(pAnn.y + dy) },
+        };
+        const wp1 = assoc.sourceRef === annId ? shifted.pAnn : shifted.pElem;
+        const wp2 = assoc.sourceRef === annId ? shifted.pElem : shifted.pAnn;
+        const waypoints = [wp1, wp2];
         allEdges.push({
             id: `${assoc.id}_di`,
             bpmnElement: assoc.id,
@@ -305,15 +214,11 @@ 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);
-        // Re-resolve edge crossings after boundary events moved shapes
-        const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
-        resolveEdgeCrossings(result.edges, nodeMap);
         if (result.nodes.length === 0)
             continue;
         // Pre-compute annotation positions in layout space so they're included in the bbox
-        const annBounds = computeAnnotationLocalBounds(process, result.nodes);
+        const annBounds = packAnnotations(process, result.nodes);
         const { minX, minY, maxX, maxY } = contentBbox(result.nodes, annBounds.values());
         const contentW = maxX - minX;
         const contentH = maxY - minY;
@@ -352,6 +257,33 @@ export function applyAutoLayout(defs) {
             poolY += innerH + POOL_GAP;
         }
     }
+    if (collab && collab.messageFlows.length > 0) {
+        const shapeByElement = new Map(allShapes.map((s) => [s.bpmnElement, s.bounds]));
+        for (const mf of collab.messageFlows) {
+            const src = shapeByElement.get(mf.sourceRef);
+            const tgt = shapeByElement.get(mf.targetRef);
+            if (!src || !tgt)
+                continue;
+            const srcBelow = src.y + src.height / 2 > tgt.y + tgt.height / 2;
+            const sx = Math.round(src.x + src.width / 2);
+            const tx = Math.round(tgt.x + tgt.width / 2);
+            const sy = srcBelow ? src.y : src.y + src.height;
+            const ty = srcBelow ? tgt.y + tgt.height : tgt.y;
+            const midY = Math.round((sy + ty) / 2);
+            const waypoints = sx === tx
+                ? [
+                    { x: sx, y: sy },
+                    { x: tx, y: ty },
+                ]
+                : [
+                    { x: sx, y: sy },
+                    { x: sx, y: midY },
+                    { x: tx, y: midY },
+                    { x: tx, y: ty },
+                ];
+            allEdges.push({ id: `${mf.id}_di`, bpmnElement: mf.id, waypoints, unknownAttributes: {} });
+        }
+    }
     const planeBpmnElement = collab?.id ?? defs.processes[0]?.id ?? "plane";
     const existingDiagram = defs.diagrams[0];
     return {

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

@@ -321,6 +321,12 @@ export declare class BranchBuilder {
      * @param handler - Callback that chains elements from the boundary event.
      */
     withBoundary(id: string, options: Omit<BoundaryEventOptions, "attachedTo">, handler: (b: BranchBuilder) => void): this;
+    /** Add a sub-process (mirrors `ProcessBuilder.subProcess`). */
+    subProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: SubProcessOptions): this;
+    /** Add an ad-hoc sub-process (mirrors `ProcessBuilder.adHocSubProcess`). */
+    adHocSubProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: AdHocSubProcessOptions): this;
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: ElementOptions): this;
     /**
      * Create a named branch from the last gateway added inside this branch.
      *
@@ -372,6 +378,30 @@ export declare class SubProcessContentBuilder {
     branch(name: string, callback: (b: BranchBuilder) => void): this;
     connectTo(targetId: string): this;
     element(elementId: string): this;
+    /**
+     * Add a boundary event attached to an existing activity in this sub-process.
+     *
+     * The boundary event is NOT connected by a sequence flow — it attaches via
+     * `attachedToRef`. The builder cursor advances to the boundary event so
+     * subsequent elements chain from it. Use `withBoundary()` if you want the
+     * cursor to return to the task afterward.
+     */
+    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: SubProcessContentBuilder) => void): this;
+    /** Add a sub-process nested inside this sub-process's content. */
+    subProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: SubProcessOptions): this;
+    /** Add an ad-hoc sub-process nested inside this sub-process's content. */
+    adHocSubProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: AdHocSubProcessOptions): this;
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id: string, content: (b: SubProcessContentBuilder) => void, options?: ElementOptions): this;
 }
 /** Fluent builder for constructing BPMN processes. */
 export declare class ProcessBuilder {