@aranzatech/diagrams-bpmn 0.3.4 → 0.3.6

package/dist/modeling/index.cjs

@@ -1151,6 +1151,83 @@ function applyBpmnPoolLaneDimensionChange(nodes, previousNodes, nodeId, width, h
   }
   return nodes;
 }
+var BPMN_CONTAINER_GROW_PAD = 24;
+function growBpmnContainersToFit(nodes, options = {}) {
+  const growPad = options.growPad ?? BPMN_CONTAINER_GROW_PAD;
+  const pad = BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad;
+  const gap = BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+  const updated = /* @__PURE__ */ new Map();
+  const contentExtent = (parentId) => {
+    let right = 0;
+    let bottom = 0;
+    for (const node of nodes) {
+      if (node.parentId !== parentId) continue;
+      if (node.data.elementType === "Lane") continue;
+      const size = getBpmnNodeSize(node);
+      right = Math.max(right, node.position.x + size.width);
+      bottom = Math.max(bottom, node.position.y + size.height);
+    }
+    return { right, bottom };
+  };
+  for (const pool of nodes) {
+    if (pool.data.elementType !== "Pool") continue;
+    if (getBpmnPoolOrientation(pool) === "vertical") continue;
+    const poolSize = getBpmnNodeSize(pool);
+    const lanes = getBpmnPoolLanesOrderedByStack(nodes, pool.id, "horizontal");
+    if (lanes.length === 0) {
+      const extent = contentExtent(pool.id);
+      if (extent.right === 0 && extent.bottom === 0) continue;
+      const poolW2 = Math.max(poolSize.width, extent.right + growPad);
+      const poolH2 = Math.max(poolSize.height, extent.bottom + growPad);
+      if (poolW2 === poolSize.width && poolH2 === poolSize.height) continue;
+      updated.set(pool.id, {
+        ...pool,
+        width: poolW2,
+        height: poolH2,
+        measured: { width: poolW2, height: poolH2 }
+      });
+      continue;
+    }
+    let requiredLaneW = Math.max(...lanes.map((l) => getBpmnNodeSize(l).width));
+    const laneHeights = /* @__PURE__ */ new Map();
+    let anyLaneGrew = false;
+    for (const laneNode of lanes) {
+      const laneSize = getBpmnNodeSize(laneNode);
+      const extent = contentExtent(laneNode.id);
+      const newH = Math.max(laneSize.height, extent.bottom + growPad);
+      laneHeights.set(laneNode.id, newH);
+      requiredLaneW = Math.max(requiredLaneW, extent.right + growPad);
+      if (newH !== laneSize.height) anyLaneGrew = true;
+    }
+    const laneW = requiredLaneW;
+    const laneWGrew = lanes.some((l) => getBpmnNodeSize(l).width !== laneW);
+    if (!anyLaneGrew && !laneWGrew) continue;
+    let cumY = pad;
+    for (const laneNode of lanes) {
+      const laneH = laneHeights.get(laneNode.id);
+      updated.set(laneNode.id, {
+        ...laneNode,
+        position: { x: pad, y: cumY },
+        width: laneW,
+        height: laneH,
+        measured: { width: laneW, height: laneH }
+      });
+      cumY += laneH + gap;
+    }
+    const poolW = Math.max(poolSize.width, laneW + pad * 2);
+    const poolH = Math.max(poolSize.height, cumY - gap + pad);
+    if (poolW !== poolSize.width || poolH !== poolSize.height) {
+      updated.set(pool.id, {
+        ...pool,
+        width: poolW,
+        height: poolH,
+        measured: { width: poolW, height: poolH }
+      });
+    }
+  }
+  if (updated.size === 0) return nodes;
+  return nodes.map((node) => updated.get(node.id) ?? node);
+}
 function resizeHorizontalBpmnLanes(lanes, pool) {
   const pad = BPMN_POOL_LANE_LAYOUT.poolPad;
   const poolSize = getBpmnNodeSize(pool);
@@ -2011,6 +2088,7 @@ exports.getBpmnPoolLanes = getBpmnPoolLanes;
 exports.getBpmnPoolOrientation = getBpmnPoolOrientation;
 exports.getBpmnTabOrder = getBpmnTabOrder;
 exports.groupAsBpmnSubProcessCommand = groupAsBpmnSubProcessCommand;
+exports.growBpmnContainersToFit = growBpmnContainersToFit;
 exports.inferBpmnEdgeType = inferBpmnEdgeType;
 exports.isBpmnDroppableInContainer = isBpmnDroppableInContainer;
 exports.isBpmnEdgeRoutingEditable = isBpmnEdgeRoutingEditable;