@bpmnkit/core 0.0.26 → 0.0.27

package/dist/bpmn/auto-layout.js

@@ -201,19 +201,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)

package/dist/layout/layout-engine.js

@@ -41,6 +41,16 @@ function repositionBoundaryEvents(flowElements, result) {
         const hostNode = nodeById.get(hostId);
         if (!hostNode)
             continue;
+        // Pre-compute distribution parameters (all boundary events share the same fixed size).
+        // Distribute events evenly along the bottom edge, centered on the task.
+        // effectiveSpacing guarantees events don't overlap (min bW + 4px gap).
+        const firstBeNode = nodeById.get(beIds[0] ?? "");
+        const bW = firstBeNode?.bounds.width ?? 36;
+        const bH = firstBeNode?.bounds.height ?? 36;
+        const n = beIds.length;
+        const effectiveSpacing = Math.max(Math.round(hostNode.bounds.width / (n + 1)), bW + 4);
+        const groupWidth = Math.max(0, n - 1) * effectiveSpacing;
+        const groupStartCenterX = Math.round(hostNode.bounds.x + hostNode.bounds.width / 2 - groupWidth / 2);
         for (let i = 0; i < beIds.length; i++) {
             const beId = beIds[i];
             if (!beId)
@@ -48,11 +58,9 @@ function repositionBoundaryEvents(flowElements, result) {
             const beNode = nodeById.get(beId);
             if (!beNode)
                 continue;
-            const bW = beNode.bounds.width;
-            const bH = beNode.bounds.height;
-            // Place boundary event on the bottom edge of the host task, stacking leftward
-            const rightEdge = hostNode.bounds.x + hostNode.bounds.width;
-            beNode.bounds.x = Math.round(rightEdge - bW / 2 - i * (bW + 4));
+            // bW / bH come from the pre-loop computation (all BEs are fixed 36×36)
+            // Center-bottom distribution: single event → task center; multiple → even spread
+            beNode.bounds.x = Math.round(groupStartCenterX + i * effectiveSpacing - bW / 2);
             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);

package/dist/layout/subprocess.js

@@ -1,5 +1,36 @@
 import { layoutFlowNodes } from "./layout-engine.js";
 import { SUBPROCESS_PADDING } from "./types.js";
+const ADHOC_MAX_COLS = 4;
+const ADHOC_H_GAP = 50;
+const ADHOC_V_GAP = 80;
+/**
+ * Rearrange disconnected adHocSubProcess tool nodes into a grid.
+ * Nodes start at (0, 0) so the subprocess padding offset applies cleanly.
+ */
+function applyAdHocGridLayout(nodes) {
+    if (nodes.length === 0)
+        return;
+    const cols = Math.min(nodes.length, ADHOC_MAX_COLS);
+    const cellW = nodes.reduce((max, n) => Math.max(max, n.bounds.width), 0);
+    const cellH = nodes.reduce((max, n) => Math.max(max, n.bounds.height), 0);
+    for (let i = 0; i < nodes.length; i++) {
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const n = nodes[i];
+        if (!n)
+            continue;
+        const newX = col * (cellW + ADHOC_H_GAP) + Math.round((cellW - n.bounds.width) / 2);
+        const newY = row * (cellH + ADHOC_V_GAP) + Math.round((cellH - n.bounds.height) / 2);
+        const dx = newX - n.bounds.x;
+        const dy = newY - n.bounds.y;
+        n.bounds.x = newX;
+        n.bounds.y = newY;
+        if (n.labelBounds) {
+            n.labelBounds.x += dx;
+            n.labelBounds.y += dy;
+        }
+    }
+}
 /**
  * Check if a node type is a sub-process container.
  */
@@ -22,6 +53,13 @@ export function layoutSubProcesses(layoutNodes, nodeIndex) {
         if (!subProcess.flowElements || subProcess.flowElements.length === 0)
             continue;
         const childResult = layoutFlowNodes(subProcess.flowElements, subProcess.sequenceFlows ?? []);
+        // For adHocSubProcess with no sequence flows, rearrange into a compact grid
+        // instead of a single long horizontal row.
+        if (bpmnNode.type === "adHocSubProcess" &&
+            (subProcess.sequenceFlows?.length ?? 0) === 0 &&
+            childResult.nodes.length > 0) {
+            applyAdHocGridLayout(childResult.nodes);
+        }
         if (childResult.nodes.length === 0)
             continue;
         // Compute bounding box of child elements

package/dist/layout/types.d.ts

@@ -5,13 +5,13 @@ export declare const ELEMENT_SIZES: Record<string, {
     height: number;
 }>;
 /** Virtual grid cell dimensions for element placement. */
-export declare const GRID_CELL_WIDTH = 130;
+export declare const GRID_CELL_WIDTH = 150;
 export declare const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export declare const HORIZONTAL_SPACING: number;
 export declare const VERTICAL_SPACING: number;
 /** Padding inside sub-process containers. */
-export declare const SUBPROCESS_PADDING = 20;
+export declare const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export declare const LABEL_CHAR_WIDTH = 7;
 export declare const LABEL_MIN_WIDTH = 40;

package/dist/layout/types.js

@@ -22,13 +22,13 @@ export const ELEMENT_SIZES = {
     eventSubProcess: { width: 100, height: 80 },
 };
 /** Virtual grid cell dimensions for element placement. */
-export const GRID_CELL_WIDTH = 130;
+export const GRID_CELL_WIDTH = 150;
 export const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export const HORIZONTAL_SPACING = GRID_CELL_WIDTH - 100; // 100 = max element width
 export const VERTICAL_SPACING = GRID_CELL_HEIGHT - 80; // 80 = max element height
 /** Padding inside sub-process containers. */
-export const SUBPROCESS_PADDING = 20;
+export const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export const LABEL_CHAR_WIDTH = 7;
 export const LABEL_MIN_WIDTH = 40;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/core",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",