@aranzatech/diagrams-bpmn 0.3.4 → 0.3.5

package/dist/index.js

@@ -1,6 +1,6 @@
 export { getAllowedEventTriggers } from './chunk-JEGYVEJO.js';
 export { AnnotationNode, BPMN_NODE_TYPES, BoundaryEventNode, CallChoreographyNode, CallConversationNode, ChoreographyTaskNode, ConversationNode, DataInputNode, DataObjectNode, DataObjectReferenceNode, DataOutputNode, DataStoreNode, DataStoreReferenceNode, EndEventNode, GatewayNode, GroupNode, IntermediateCatchEventNode, IntermediateThrowEventNode, LaneNode, PoolNode, StartEventNode, SubChoreographyNode, SubConversationNode, SubProcessNode, TaskNode } from './chunk-X54NHLBA.js';
-export { AssociationEdge, BPMN_EDGE_TYPES, ConversationLinkEdge, DataAssociationEdge, MessageFlowEdge, SequenceFlowEdge } from './chunk-CPFUQM6H.js';
+export { AssociationEdge, BPMN_EDGE_TYPES, ConversationLinkEdge, DataAssociationEdge, MessageFlowEdge, SequenceFlowEdge } from './chunk-JFYWN6QH.js';
 import './chunk-PDTXM32P.js';
 export { parseBpmnXml, serializeBpmnXml } from './chunk-NYIYQUGX.js';
 import './chunk-77L6O76M.js';

package/dist/layout/index.cjs

@@ -1576,23 +1576,44 @@ function layoutPool(pool, lanes, content, allEdges) {
       laneStats.set(laneId, { minRow, maxRow, rowCount, height });
     }
   }
-  const maxCol = Math.max(0, ...[...columns.values()]);
-  const colW = /* @__PURE__ */ new Map();
-  for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
-  for (const node of mainContent) {
-    const c = columns.get(node.id) ?? 0;
-    colW.set(c, Math.max(colW.get(c) ?? 0, layoutW(node)));
-  }
-  const colX = /* @__PURE__ */ new Map();
-  let cumX = 0;
-  for (let c = 0; c <= maxCol; c++) {
-    colX.set(c, cumX);
-    cumX += (colW.get(c) ?? 120) + COL_GAP;
+  const laneColumnLayouts = /* @__PURE__ */ new Map();
+  for (const laneId of laneIds) {
+    const laneNodes = mainContent.filter(
+      (node) => (nodeLaneId.get(node.id) ?? "_pool_") === laneId
+    );
+    const usedCols = [...new Set(laneNodes.map((node) => columns.get(node.id) ?? 0))].sort((a, b) => a - b);
+    const colW = /* @__PURE__ */ new Map();
+    for (const col of usedCols) colW.set(col, 0);
+    for (const node of laneNodes) {
+      const col = columns.get(node.id) ?? 0;
+      colW.set(col, Math.max(colW.get(col) ?? 0, layoutW(node)));
+    }
+    const colX = /* @__PURE__ */ new Map();
+    let laneCumX = 0;
+    for (const col of usedCols) {
+      colX.set(col, laneCumX);
+      laneCumX += (colW.get(col) ?? 120) + COL_GAP;
+    }
+    laneColumnLayouts.set(laneId, {
+      colW,
+      colX,
+      contentW: usedCols.length > 0 ? laneCumX - COL_GAP : 0
+    });
   }
-  const contentW = cumX - COL_GAP;
-  const innerW = LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+  const baseLaneInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId !== "_pool_").map((laneId) => {
+      const contentW = laneColumnLayouts.get(laneId)?.contentW ?? 0;
+      return LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+    })
+  );
+  const basePoolInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId === "_pool_").map((laneId) => (laneColumnLayouts.get(laneId)?.contentW ?? 0) + POOL_H_PAD * 2)
+  );
+  const innerW = Math.max(baseLaneInnerW, basePoolInnerW);
   const poolW = Math.max(POOL_MIN_W, innerW + POOL_INNER_PAD * 2);
-  const laneW = poolW - POOL_INNER_PAD * 2;
+  let laneW = poolW - POOL_INNER_PAD * 2;
   const laneY = /* @__PURE__ */ new Map();
   let cumY = POOL_INNER_PAD;
   for (let i = 0; i < laneIds.length; i++) {
@@ -1607,10 +1628,11 @@ function layoutPool(pool, lanes, content, allEdges) {
     const r = rows.get(node.id) ?? 0;
     const laneId = nodeLaneId.get(node.id) ?? "_pool_";
     const stat = laneStats.get(laneId);
+    const laneLayout = laneColumnLayouts.get(laneId);
     const lYOff = laneY.get(laneId) ?? 0;
     const lw = layoutW(node);
     const lh = layoutH(node);
-    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - lw / 2;
+    const colOffset = (laneLayout?.colX.get(c) ?? 0) + (laneLayout?.colW.get(c) ?? 120) / 2 - lw / 2;
     const rowOffset = (r - stat.minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - lh / 2;
     const contentH_stat = stat.rowCount * ROW_HEIGHT + Math.max(0, stat.rowCount - 1) * ROW_GAP;
     const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - contentH_stat) / 2);
@@ -1619,8 +1641,94 @@ function layoutPool(pool, lanes, content, allEdges) {
     const y = isLaneChild ? vertTopOffset + rowOffset : lYOff + vertTopOffset + rowOffset;
     return applyLayoutMinSize({ ...node, position: { x, y } });
   });
+  const handoffAdjustedContent = [...positionedContent];
+  const nodeIndexById = new Map(handoffAdjustedContent.map((node, index) => [node.id, index]));
+  const outgoingBySource = /* @__PURE__ */ new Map();
+  for (const edge of fwdEdges) {
+    if (!outgoingBySource.has(edge.source)) outgoingBySource.set(edge.source, []);
+    outgoingBySource.get(edge.source).push(edge);
+  }
+  const crossLaneEdges = fwdEdges.filter((edge) => {
+    const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+    const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+    return srcLane !== tgtLane;
+  }).sort(
+    (a, b) => (columns.get(a.target) ?? 0) - (columns.get(b.target) ?? 0) || (columns.get(a.source) ?? 0) - (columns.get(b.source) ?? 0)
+  );
+  for (const edge of crossLaneEdges) {
+    const srcIndex = nodeIndexById.get(edge.source);
+    const tgtIndex = nodeIndexById.get(edge.target);
+    if (srcIndex == null || tgtIndex == null) continue;
+    const srcNode = handoffAdjustedContent[srcIndex];
+    const tgtNode = handoffAdjustedContent[tgtIndex];
+    const tgtLaneId = nodeLaneId.get(tgtNode.id) ?? "_pool_";
+    const tgtCol = columns.get(tgtNode.id) ?? 0;
+    const siblingTargets = (outgoingBySource.get(edge.source) ?? []).filter((candidate) => (columns.get(candidate.target) ?? 0) === tgtCol).map((candidate) => handoffAdjustedContent[nodeIndexById.get(candidate.target) ?? -1]).filter((node) => !!node);
+    const siblingAlignedX = siblingTargets.reduce(
+      (max, node) => Math.max(max, node.position.x),
+      Number.NEGATIVE_INFINITY
+    );
+    const minTargetX = Math.max(
+      siblingAlignedX,
+      srcNode.position.x + layoutW(srcNode) / 2 + layoutW(tgtNode) / 2 + COL_GAP
+    );
+    if (tgtNode.position.x >= minTargetX) continue;
+    const delta = minTargetX - tgtNode.position.x;
+    for (let i = 0; i < handoffAdjustedContent.length; i++) {
+      const candidate = handoffAdjustedContent[i];
+      if ((nodeLaneId.get(candidate.id) ?? "_pool_") !== tgtLaneId) continue;
+      if ((columns.get(candidate.id) ?? 0) < tgtCol) continue;
+      handoffAdjustedContent[i] = {
+        ...candidate,
+        position: {
+          x: candidate.position.x + delta,
+          y: candidate.position.y
+        }
+      };
+    }
+  }
+  for (const [sourceId, outgoing] of outgoingBySource) {
+    if (outgoing.length < 2) continue;
+    const hasCrossLaneSibling = outgoing.some((edge) => {
+      const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+      const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+      return srcLane !== tgtLane;
+    });
+    if (!hasCrossLaneSibling) continue;
+    const siblingsByCol = /* @__PURE__ */ new Map();
+    for (const edge of outgoing) {
+      const col = columns.get(edge.target) ?? 0;
+      const node = handoffAdjustedContent[nodeIndexById.get(edge.target) ?? -1];
+      if (!node) continue;
+      if (!siblingsByCol.has(col)) siblingsByCol.set(col, []);
+      siblingsByCol.get(col).push(node);
+    }
+    for (const [col, siblings] of siblingsByCol) {
+      if (siblings.length < 2) continue;
+      const alignedX = Math.max(...siblings.map((node) => node.position.x));
+      for (let i = 0; i < handoffAdjustedContent.length; i++) {
+        const candidate = handoffAdjustedContent[i];
+        if (!siblings.some((node) => node.id === candidate.id)) continue;
+        const laneId = nodeLaneId.get(candidate.id) ?? "_pool_";
+        for (let j = 0; j < handoffAdjustedContent.length; j++) {
+          const maybeShift = handoffAdjustedContent[j];
+          if ((nodeLaneId.get(maybeShift.id) ?? "_pool_") !== laneId) continue;
+          if ((columns.get(maybeShift.id) ?? 0) < col) continue;
+          const delta = alignedX - candidate.position.x;
+          if (delta <= 0) continue;
+          handoffAdjustedContent[j] = {
+            ...maybeShift,
+            position: {
+              x: maybeShift.position.x + delta,
+              y: maybeShift.position.y
+            }
+          };
+        }
+      }
+    }
+  }
   const NODE_MIN_GAP = 24;
-  const resolvedContent = [...positionedContent];
+  const resolvedContent = [...handoffAdjustedContent];
   for (const laneId of laneIds) {
     const laneNodeIndices = resolvedContent.map((n, i) => ({ n, i })).filter(({ n }) => (nodeLaneId.get(n.id) ?? "_pool_") === laneId).sort((a, b) => a.n.position.x - b.n.position.x);
     for (let k = 1; k < laneNodeIndices.length; k++) {
@@ -1642,6 +1750,15 @@ function layoutPool(pool, lanes, content, allEdges) {
     }
   }
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, resolvedContent);
+  const laneChildRight = resolvedContent.filter((node) => hasLanes && !!node.parentId && node.parentId !== pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + LANE_H_PAD), 0);
+  const poolChildRight = resolvedContent.filter((node) => !hasLanes || !node.parentId || node.parentId === pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + POOL_H_PAD), 0);
+  const boundaryRight = positionedBoundaries.reduce(
+    (max, node) => Math.max(max, node.position.x + nW(node) + (hasLanes ? LANE_H_PAD : POOL_H_PAD)),
+    0
+  );
+  const finalInnerW = Math.max(innerW, laneChildRight, poolChildRight, boundaryRight);
+  const finalPoolW = Math.max(POOL_MIN_W, finalInnerW + POOL_INNER_PAD * 2);
+  laneW = finalPoolW - POOL_INNER_PAD * 2;
   const positionedLanes = hasLanes ? sortedLanes.map((lane) => ({
     ...lane,
     position: { x: POOL_INNER_PAD, y: laneY.get(lane.id) ?? POOL_INNER_PAD },
@@ -1650,7 +1767,7 @@ function layoutPool(pool, lanes, content, allEdges) {
   })) : [];
   return {
     nodes: [...resolvedContent, ...positionedBoundaries, ...positionedLanes],
-    width: poolW,
+    width: finalPoolW,
     height: poolH
   };
 }