@aranzatech/diagrams-bpmn 0.3.2 → 0.3.4

package/dist/layout/index.js

@@ -135,6 +135,17 @@ function detectGatewayPairs(nodes, forwardEdges) {
   }
   return pairs;
 }
+function createSecondaryOffsets(count) {
+  if (count <= 0) return [];
+  const offsets = [];
+  let step = 1;
+  while (offsets.length < count) {
+    offsets.push(-step);
+    if (offsets.length < count) offsets.push(step);
+    step++;
+  }
+  return offsets;
+}
 function handleToRowBias(handle) {
   if (!handle) return null;
   if (handle.includes("top")) return -1;
@@ -150,6 +161,52 @@ function buildHandleMap(edges) {
   }
   return map;
 }
+function pickMainBranch(branchData) {
+  if (branchData.length === 0) return void 0;
+  return [...branchData].sort((a, b) => {
+    const aRight = a.bias === 0 ? 1 : 0;
+    const bRight = b.bias === 0 ? 1 : 0;
+    if (aRight !== bRight) return bRight - aRight;
+    if (a.nodeIds.length !== b.nodeIds.length) return b.nodeIds.length - a.nodeIds.length;
+    return a.start.localeCompare(b.start);
+  })[0]?.start;
+}
+function resolveDirectionalRow(splitRow, preferredOffset, usedRows) {
+  if (preferredOffset === 0 && !usedRows.has(splitRow)) return splitRow;
+  const direction = preferredOffset < 0 ? -1 : 1;
+  let distance = Math.max(1, Math.abs(preferredOffset));
+  while (usedRows.has(splitRow + direction * distance)) distance++;
+  return splitRow + direction * distance;
+}
+function assignBranchRowsAroundMain(branchData, splitRow) {
+  const assigned = /* @__PURE__ */ new Map();
+  const mainBranchStart = pickMainBranch(branchData);
+  if (mainBranchStart) assigned.set(mainBranchStart, splitRow);
+  const usedRows = new Set(assigned.values());
+  const remaining = branchData.filter((branch) => branch.start !== mainBranchStart);
+  const withBias = remaining.filter((branch) => branch.bias !== null && branch.bias !== 0).sort((a, b) => {
+    const aMag = Math.abs(a.bias ?? 0);
+    const bMag = Math.abs(b.bias ?? 0);
+    if (aMag !== bMag) return aMag - bMag;
+    return a.start.localeCompare(b.start);
+  });
+  const withoutBias = remaining.filter((branch) => branch.bias === null || branch.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length || a.start.localeCompare(b.start));
+  for (const branch of withBias) {
+    const row = resolveDirectionalRow(splitRow, branch.bias ?? 0, usedRows);
+    assigned.set(branch.start, row);
+    usedRows.add(row);
+  }
+  const preferredOffsets = createSecondaryOffsets(withoutBias.length);
+  for (let i = 0; i < withoutBias.length; i++) {
+    let row = splitRow + preferredOffsets[i];
+    if (usedRows.has(row)) {
+      row = resolveDirectionalRow(splitRow, preferredOffsets[i], usedRows);
+    }
+    assigned.set(withoutBias[i].start, row);
+    usedRows.add(row);
+  }
+  return assigned;
+}
 function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   const rows = new Map(nodes.map((n) => [n.id, 0]));
   const succs = new Map(nodes.map((n) => [n.id, []]));
@@ -183,24 +240,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       nodeIds: getBranchNodes(start),
       bias: handleToRowBias(splitHandles?.get(start) ?? null)
     }));
-    const withBias = branchData.filter((b) => b.bias !== null && b.bias !== 0);
-    const withoutBias = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
-    const assigned = /* @__PURE__ */ new Map();
-    for (const b of withBias) {
-      assigned.set(b.start, splitRow + b.bias);
-    }
-    let nextOffset = 0;
-    for (const b of withoutBias) {
-      while ([...assigned.values()].includes(splitRow + nextOffset)) nextOffset++;
-      assigned.set(b.start, splitRow + nextOffset);
-      nextOffset++;
-    }
+    const assigned = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned.get(b.start) ?? splitRow;
       for (const id of b.nodeIds) {
         rows.set(id, row);
       }
     }
+    rows.set(mergeId, splitRow);
   }
   const pairedSplits = new Set(gatewayPairs.keys());
   const unpairedSplits = nodes.filter(
@@ -229,16 +276,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       nodeIds: getAllReachable(start),
       bias: handleToRowBias(splitHandles2?.get(start) ?? null)
     }));
-    const withBias2 = branchData.filter((b) => b.bias !== null && b.bias !== 0);
-    const withoutBias2 = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
-    const assigned2 = /* @__PURE__ */ new Map();
-    for (const b of withBias2) assigned2.set(b.start, splitRow + b.bias);
-    let nextOff = 0;
-    for (const b of withoutBias2) {
-      while ([...assigned2.values()].includes(splitRow + nextOff)) nextOff++;
-      assigned2.set(b.start, splitRow + nextOff);
-      nextOff++;
-    }
+    const assigned2 = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned2.get(b.start) ?? splitRow;
       for (const id of b.nodeIds) rows.set(id, row);
@@ -260,6 +298,7 @@ var LANE_MIN_H = 180;
 var POOL_MIN_W = 720;
 var POOL_INNER_PAD = 10;
 var BACK_EDGE_CLEARANCE = 56;
+var EDGE_ROUTE_PAD = 28;
 var LAYOUT_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   "DataObject",
   "DataObjectReference",
@@ -568,8 +607,54 @@ function absolutePos(nodeId, byId, cache) {
   cache.set(nodeId, abs);
   return abs;
 }
-function laneOf(node, laneIds) {
-  return node.parentId && laneIds.has(node.parentId) ? node.parentId : void 0;
+function findAncestorNodeId(node, candidateIds, byId) {
+  let current = node;
+  while (current?.parentId) {
+    if (candidateIds.has(current.parentId)) return current.parentId;
+    current = byId.get(current.parentId);
+  }
+  return void 0;
+}
+function laneOf(node, laneIds, byId) {
+  return findAncestorNodeId(node, laneIds, byId);
+}
+function poolOf(node, poolIds, byId) {
+  if (poolIds.has(node.id)) return node.id;
+  return findAncestorNodeId(node, poolIds, byId);
+}
+function nodeRect(node, byId, cache) {
+  const pos = absolutePos(node.id, byId, cache);
+  return { x: pos.x, y: pos.y, width: nW(node), height: nH(node) };
+}
+function rectContainsRect(outer, inner) {
+  return inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
+}
+function sortNodesParentFirst(nodes) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const memo = /* @__PURE__ */ new Map();
+  const depthOf = (node) => {
+    const cached = memo.get(node.id);
+    if (cached != null) return cached;
+    if (!node.parentId) {
+      memo.set(node.id, 0);
+      return 0;
+    }
+    const parent = byId.get(node.parentId);
+    const depth = parent ? depthOf(parent) + 1 : 0;
+    memo.set(node.id, depth);
+    return depth;
+  };
+  return [...nodes].sort((a, b) => {
+    const depthDiff = depthOf(a) - depthOf(b);
+    if (depthDiff !== 0) return depthDiff;
+    const ay = a.position?.y ?? 0;
+    const by = b.position?.y ?? 0;
+    if (ay !== by) return ay - by;
+    const ax = a.position?.x ?? 0;
+    const bx = b.position?.x ?? 0;
+    if (ax !== bx) return ax - bx;
+    return a.id.localeCompare(b.id);
+  });
 }
 function gapMidX(sAbs, sW, tAbs, tW) {
   const leftRightEdge = Math.min(sAbs.x + sW, tAbs.x + tW);
@@ -605,18 +690,9 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     const tCX = tAbs.x + tW / 2;
     const sCY = sAbs.y + sH / 2;
     const tCY = tAbs.y + tH / 2;
-    const getPool = (nodeId) => {
-      const node = byId.get(nodeId);
-      if (!node) return null;
-      if (poolIds.has(nodeId)) return nodeId;
-      if (node.parentId && poolIds.has(node.parentId)) return node.parentId;
-      if (node.parentId) {
-        const gp = byId.get(node.parentId)?.parentId ?? null;
-        if (gp && poolIds.has(gp)) return gp;
-      }
-      return node.parentId ?? null;
-    };
-    if (getPool(edge.source) !== getPool(edge.target)) {
+    const srcPool = poolOf(src, poolIds, byId) ?? null;
+    const tgtPool = poolOf(tgt, poolIds, byId) ?? null;
+    if (srcPool !== tgtPool) {
       const d = { ...edge.data };
       delete d.routingPoints;
       return { ...edge, data: d };
@@ -625,14 +701,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     if (backEdgeIds.has(edge.id)) {
       const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
       routingPoints = [
-        { x: sCX, y: sAbs.y },
-        { x: sCX, y: topY },
-        { x: tCX, y: topY },
-        { x: tCX, y: tAbs.y + tH }
+        { x: sAbs.x + sW, y: sCY },
+        { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: sCY },
+        { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: topY },
+        { x: tAbs.x - EDGE_ROUTE_PAD, y: topY },
+        { x: tAbs.x - EDGE_ROUTE_PAD, y: tCY },
+        { x: tAbs.x, y: tCY }
       ];
-    } else if (laneOf(src, laneIds) !== laneOf(tgt, laneIds)) {
-      const srcLane = byId.get(src.parentId ?? "");
-      const tgtLane = byId.get(tgt.parentId ?? "");
+    } else if (laneOf(src, laneIds, byId) !== laneOf(tgt, laneIds, byId)) {
+      const srcLane = byId.get(laneOf(src, laneIds, byId) ?? "");
+      const tgtLane = byId.get(laneOf(tgt, laneIds, byId) ?? "");
       if (srcLane && tgtLane && laneIds.has(srcLane.id) && laneIds.has(tgtLane.id)) {
         const goingDown = tAbs.y > sAbs.y;
         const sharedX = gapMidX(sAbs, sW, tAbs, tW);
@@ -640,8 +718,8 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         const tgtLaneIdx = sortedLanes.findIndex((l) => l.id === tgtLane.id);
         const pts = [];
         if (goingDown) {
-          pts.push({ x: sCX, y: sAbs.y + sH });
-          pts.push({ x: sharedX, y: sAbs.y + sH });
+          pts.push({ x: sAbs.x + sW, y: sCY });
+          pts.push({ x: sharedX, y: sCY });
           const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
           const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
           for (let i = fromIdx; i < toIdx; i++) {
@@ -650,11 +728,12 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
             pts.push({ x: sharedX, y: laneBot });
           }
           const lastY = pts[pts.length - 1].y;
-          pts.push({ x: tCX, y: lastY });
-          pts.push({ x: tCX, y: tAbs.y + tH });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: lastY });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: tCY });
+          pts.push({ x: tAbs.x, y: tCY });
         } else {
-          pts.push({ x: sCX, y: sAbs.y });
-          pts.push({ x: sharedX, y: sAbs.y });
+          pts.push({ x: sAbs.x + sW, y: sCY });
+          pts.push({ x: sharedX, y: sCY });
           const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
           const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
           for (let i = toIdx; i > fromIdx; i--) {
@@ -663,17 +742,18 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
             pts.push({ x: sharedX, y: laneTop });
           }
           const lastY = pts[pts.length - 1].y;
-          pts.push({ x: tCX, y: lastY });
-          pts.push({ x: tCX, y: tAbs.y });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: lastY });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: tCY });
+          pts.push({ x: tAbs.x, y: tCY });
         }
         routingPoints = pts;
       } else {
         const sharedX = gapMidX(sAbs, sW, tAbs, tW);
         routingPoints = [
-          { x: sCX, y: sCY },
+          { x: sAbs.x + sW, y: sCY },
           { x: sharedX, y: sCY },
           { x: sharedX, y: tCY },
-          { x: tCX, y: tCY }
+          { x: tAbs.x, y: tCY }
         ];
       }
     } else if (Math.abs(sCY - tCY) <= SAME_ROW_THRESHOLD) {
@@ -685,19 +765,25 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       const exitsTop = handle.includes("top");
       const exitsBottom = handle.includes("bottom");
       if (exitsTop || exitsBottom) {
+        const exitY = exitsTop ? sAbs.y : sAbs.y + sH;
+        const entryY = exitsTop ? tAbs.y + tH : tAbs.y;
+        const corridorY = exitsTop ? Math.min(exitY, entryY) - EDGE_ROUTE_PAD : Math.max(exitY, entryY) + EDGE_ROUTE_PAD;
         routingPoints = [
-          { x: sCX, y: exitsTop ? sAbs.y : sAbs.y + sH },
-          { x: sCX, y: tCY },
-          { x: tCX, y: tCY },
-          { x: tCX, y: exitsTop ? tAbs.y + tH : tAbs.y }
+          { x: sCX, y: exitY },
+          { x: sCX, y: corridorY },
+          { x: tCX, y: corridorY },
+          { x: tCX, y: entryY }
         ];
       } else {
         const midX = routeMidX(sAbs, sW, tAbs, tW);
+        const exitX = sAbs.x + sW;
+        const entryX = tAbs.x;
+        const corridorX = Math.max(midX, exitX + EDGE_ROUTE_PAD);
         routingPoints = [
-          { x: sAbs.x + sW, y: sCY },
-          { x: midX, y: sCY },
-          { x: midX, y: tCY },
-          { x: tAbs.x, y: tCY }
+          { x: exitX, y: sCY },
+          { x: corridorX, y: sCY },
+          { x: corridorX, y: tCY },
+          { x: entryX, y: tCY }
         ];
       }
     }
@@ -706,16 +792,19 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
 }
 var ARTIFACT_ABOVE_GAP = 16;
 var ARTIFACT_H_SPACING = 12;
-function positionArtifacts(artifacts, resultNodes, edges) {
+function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
   if (artifacts.length === 0) return [];
   const byId = new Map(resultNodes.map((n) => [n.id, n]));
   const cache = /* @__PURE__ */ new Map();
   const absPos = (id) => absolutePos(id, byId, cache);
+  const originalById = new Map(originalNodes.map((n) => [n.id, n]));
+  const originalCache = /* @__PURE__ */ new Map();
   const artifactsByNode = /* @__PURE__ */ new Map();
   const ungrouped = [];
+  const groups = [];
   for (const artifact of artifacts) {
     if (artifact.data.elementType === "Group") {
-      ungrouped.push(artifact);
+      groups.push(artifact);
       continue;
     }
     const connEdge = edges.find((e) => {
@@ -753,6 +842,58 @@ function positionArtifacts(artifacts, resultNodes, edges) {
       desiredAbsX += nW(artifact) + ARTIFACT_H_SPACING;
     }
   }
+  const nonArtifactOriginalNodes = originalNodes.filter(
+    (node) => !LAYOUT_ARTIFACT_TYPES.has(node.data.elementType)
+  );
+  for (const group of groups) {
+    const originalGroup = originalById.get(group.id);
+    if (!originalGroup) {
+      positioned.push(group);
+      continue;
+    }
+    const groupRect = nodeRect(originalGroup, originalById, originalCache);
+    const containedOriginalIds = nonArtifactOriginalNodes.filter((node) => node.id !== group.id).filter((node) => {
+      if (node.parentId !== group.parentId) return false;
+      return rectContainsRect(groupRect, nodeRect(node, originalById, originalCache));
+    }).map((node) => node.id);
+    if (containedOriginalIds.length === 0) {
+      positioned.push(group);
+      continue;
+    }
+    const containedLaidOut = containedOriginalIds.map((id) => byId.get(id)).filter((node) => !!node);
+    if (containedLaidOut.length === 0) {
+      positioned.push(group);
+      continue;
+    }
+    const GROUP_PAD_X = 24;
+    const GROUP_PAD_Y = 20;
+    const bounds = containedLaidOut.reduce(
+      (acc, node) => {
+        const rect = nodeRect(node, byId, cache);
+        return {
+          left: Math.min(acc.left, rect.x),
+          top: Math.min(acc.top, rect.y),
+          right: Math.max(acc.right, rect.x + rect.width),
+          bottom: Math.max(acc.bottom, rect.y + rect.height)
+        };
+      },
+      { left: Number.POSITIVE_INFINITY, top: Number.POSITIVE_INFINITY, right: Number.NEGATIVE_INFINITY, bottom: Number.NEGATIVE_INFINITY }
+    );
+    const parentAbsP = group.parentId ? absPos(group.parentId) : { x: 0, y: 0 };
+    positioned.push({
+      ...group,
+      position: {
+        x: bounds.left - GROUP_PAD_X - parentAbsP.x,
+        y: bounds.top - GROUP_PAD_Y - parentAbsP.y
+      },
+      width: bounds.right - bounds.left + GROUP_PAD_X * 2,
+      height: bounds.bottom - bounds.top + GROUP_PAD_Y * 2,
+      measured: {
+        width: bounds.right - bounds.left + GROUP_PAD_X * 2,
+        height: bounds.bottom - bounds.top + GROUP_PAD_Y * 2
+      }
+    });
+  }
   return positioned;
 }
 async function bpmnCustomLayout(nodes, edges) {
@@ -787,8 +928,8 @@ async function bpmnCustomLayout(nodes, edges) {
   if (pools.length === 0) {
     const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-QT7H4252.js');
     const elkResult = await bpmnElkLayout2(nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType)), edges);
-    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges);
-    return { nodes: [...elkResult.nodes, ...posArtifacts], edges: elkResult.edges };
+    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges, nodes);
+    return { nodes: sortNodesParentFirst([...elkResult.nodes, ...posArtifacts]), edges: elkResult.edges };
   }
   const poolIds = new Set(pools.map((p) => p.id));
   const allLaneIds = new Set(lanes.map((l) => l.id));
@@ -831,8 +972,9 @@ async function bpmnCustomLayout(nodes, edges) {
   const layoutted = new Set(resultNodes.map((n) => n.id));
   const freeNodes = workingMainNodes.filter((n) => !layoutted.has(n.id));
   if (freeNodes.length > 0) {
+    const freeNodeIds = new Set(freeNodes.map((n) => n.id));
     const freeEdges = edges.filter(
-      (e) => freeNodes.some((n) => n.id === e.source || n.id === e.target)
+      (e) => freeNodeIds.has(e.source) && freeNodeIds.has(e.target)
     );
     try {
       const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-QT7H4252.js');
@@ -856,9 +998,9 @@ async function bpmnCustomLayout(nodes, edges) {
     }
   }
   const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
-  const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges);
+  const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges, nodes);
   return {
-    nodes: [...resultNodes, ...positionedArtifacts],
+    nodes: sortNodesParentFirst([...resultNodes, ...positionedArtifacts]),
     edges: routedEdges
   };
 }