@ktrysmt/beautiful-mermaid 1.4.0 → 1.4.2

package/dist/index.js

@@ -416,7 +416,7 @@ function parseFlowchart(lines) {
     const subgraphMatch = line.match(/^subgraph\s+(.+)$/);
     if (subgraphMatch) {
       const rest = subgraphMatch[1].trim();
-      const bracketMatch = rest.match(/^([\w-]+)\s*\[(.+)\]$/);
+      const bracketMatch = rest.match(/^([\w\p{L}-]+)\s*\[(.+)\]$/u);
       let id;
       let label;
       if (bracketMatch) {
@@ -424,7 +424,7 @@ function parseFlowchart(lines) {
         label = normalizeBrTags(bracketMatch[2]);
       } else {
         label = normalizeBrTags(rest);
-        id = rest.replace(/\s+/g, "_").replace(/[^\w]/g, "");
+        id = rest.replace(/\s+/g, "_").replace(/[^\p{L}\p{N}\w]/gu, "");
       }
       const sg = { id, label, nodeIds: [], children: [] };
       subgraphStack.push(sg);
@@ -1606,6 +1606,18 @@ function buildSgMap(mSgs, aSgs, result) {
   }
 }
 
+// src/ascii/multiline-utils.ts
+function splitLines(label) {
+  return label.split("\n");
+}
+function maxLineWidth(label) {
+  const lines = splitLines(label);
+  return Math.max(...lines.map((l) => displayWidth(l)), 0);
+}
+function lineCount(label) {
+  return splitLines(label).length;
+}
+
 // src/ascii/pathfinder.ts
 var MinHeap = class {
   items = [];
@@ -1894,7 +1906,7 @@ function determinePath(graph, edge) {
 }
 function determineLabelLine(graph, edge) {
   if (edge.text.length === 0) return;
-  const lenLabel = displayWidth(edge.text);
+  const lenLabel = maxLineWidth(edge.text);
   const pathLen = edge.path.length;
   const isVerticalFlow = graph.config.graphDirection === "TD";
   const segments = [];
@@ -2095,18 +2107,6 @@ function processBundles(graph) {
   }
 }
 
-// src/ascii/multiline-utils.ts
-function splitLines(label) {
-  return label.split("\n");
-}
-function maxLineWidth(label) {
-  const lines = splitLines(label);
-  return Math.max(...lines.map((l) => displayWidth(l)), 0);
-}
-function lineCount(label) {
-  return splitLines(label).length;
-}
-
 // src/ascii/shapes/corners.ts
 var SHAPE_CORNERS = {
   // Standard rectangular shapes
@@ -3652,18 +3652,37 @@ function ensureSubgraphSpacing(graph) {
     for (let j = i + 1; j < rootSubgraphs.length; j++) {
       const sg1 = rootSubgraphs[i];
       const sg2 = rootSubgraphs[j];
-      if (sg1.minX < sg2.maxX && sg1.maxX > sg2.minX) {
-        if (sg1.maxY >= sg2.minY - minSpacing && sg1.minY < sg2.minY) {
-          sg2.minY = sg1.maxY + minSpacing + 1;
-        } else if (sg2.maxY >= sg1.minY - minSpacing && sg2.minY < sg1.minY) {
-          sg1.minY = sg2.maxY + minSpacing + 1;
+      const hOverlap = sg1.minX <= sg2.maxX && sg1.maxX >= sg2.minX;
+      const vOverlap = sg1.minY <= sg2.maxY && sg1.maxY >= sg2.minY;
+      if (!hOverlap || !vOverlap) continue;
+      if (hOverlap) {
+        if (sg1.maxY >= sg2.minY - minSpacing && sg1.minY <= sg2.minY) {
+          const newMinY = sg1.maxY + minSpacing + 1;
+          if (newMinY > sg2.maxY) {
+            sg2.maxY = newMinY + (sg2.maxY - sg2.minY);
+          }
+          sg2.minY = newMinY;
+        } else if (sg2.maxY >= sg1.minY - minSpacing && sg2.minY <= sg1.minY) {
+          const newMinY = sg2.maxY + minSpacing + 1;
+          if (newMinY > sg1.maxY) {
+            sg1.maxY = newMinY + (sg1.maxY - sg1.minY);
+          }
+          sg1.minY = newMinY;
         }
       }
-      if (sg1.minY < sg2.maxY && sg1.maxY > sg2.minY) {
-        if (sg1.maxX >= sg2.minX - minSpacing && sg1.minX < sg2.minX) {
-          sg2.minX = sg1.maxX + minSpacing + 1;
-        } else if (sg2.maxX >= sg1.minX - minSpacing && sg2.minX < sg1.minX) {
-          sg1.minX = sg2.maxX + minSpacing + 1;
+      if (sg1.minY <= sg2.maxY && sg1.maxY >= sg2.minY) {
+        if (sg1.maxX >= sg2.minX - minSpacing && sg1.minX <= sg2.minX) {
+          const newMinX = sg1.maxX + minSpacing + 1;
+          if (newMinX > sg2.maxX) {
+            sg2.maxX = newMinX + (sg2.maxX - sg2.minX);
+          }
+          sg2.minX = newMinX;
+        } else if (sg2.maxX >= sg1.minX - minSpacing && sg2.minX <= sg1.minX) {
+          const newMinX = sg2.maxX + minSpacing + 1;
+          if (newMinX > sg1.maxX) {
+            sg1.maxX = newMinX + (sg1.maxX - sg1.minX);
+          }
+          sg1.minX = newMinX;
         }
       }
     }
@@ -3732,6 +3751,14 @@ function createMapping(graph) {
     }
   }
   const shouldSeparate = dir === "LR" && hasExternalRoots && hasSubgraphRootsWithEdges;
+  const downstreamSgs = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    const fromSg = getNodeSubgraph(graph, edge.from);
+    const toSg = getNodeSubgraph(graph, edge.to);
+    if (fromSg && toSg && fromSg !== toSg && !fromSg.parent && !toSg.parent) {
+      downstreamSgs.add(toSg);
+    }
+  }
   let externalRootNodes;
   let subgraphRootNodes = [];
   if (shouldSeparate) {
@@ -3740,8 +3767,18 @@ function createMapping(graph) {
   } else {
     externalRootNodes = rootNodes;
   }
-  const rootsByTarget = /* @__PURE__ */ new Map();
+  const deferredRoots = /* @__PURE__ */ new Set();
+  const primaryRoots = [];
   for (const root of externalRootNodes) {
+    const sg = getNodeSubgraph(graph, root);
+    if (sg && downstreamSgs.has(sg)) {
+      deferredRoots.add(root);
+    } else {
+      primaryRoots.push(root);
+    }
+  }
+  const rootsByTarget = /* @__PURE__ */ new Map();
+  for (const root of primaryRoots) {
     const children = getChildren(graph, root);
     const targetName = children.length > 0 ? children[0].name : "__ungrouped__";
     const group = rootsByTarget.get(targetName) ?? [];
@@ -3767,7 +3804,7 @@ function createMapping(graph) {
   for (const edge of graph.edges) {
     inDegree.set(edge.to.name, (inDegree.get(edge.to.name) ?? 0) + 1);
   }
-  let placedCount = externalRootNodes.length + subgraphRootNodes.length;
+  let placedCount = primaryRoots.length + subgraphRootNodes.length;
   while (placedCount < graph.nodes.length) {
     const prevCount = placedCount;
     for (const node of graph.nodes) {
@@ -3778,7 +3815,25 @@ function createMapping(graph) {
         const parentSg = getNodeSubgraph(graph, node);
         const childSg = getNodeSubgraph(graph, child);
         const edgeDir = parentSg && parentSg === childSg && parentSg.direction ? parentSg.direction : graph.config.graphDirection;
-        const childLevel = edgeDir === "LR" ? gc.x + 4 : gc.y + 4;
+        let childLevel = edgeDir === "LR" ? gc.x + 4 : gc.y + 4;
+        if (childSg && parentSg !== childSg && deferredRoots.size > 0) {
+          let placedDeferred = false;
+          for (const dr of [...deferredRoots]) {
+            if (dr.gridCoord !== null) continue;
+            const drSg = getNodeSubgraph(graph, dr);
+            if (drSg !== childSg) continue;
+            const drPerp = highestPositionPerLevel[childLevel] ?? 0;
+            const drRequested = edgeDir === "LR" ? { x: childLevel, y: drPerp } : { x: drPerp, y: childLevel };
+            reserveSpotInGrid(graph, graph.nodes[dr.index], drRequested, edgeDir);
+            highestPositionPerLevel[childLevel] = drPerp + 4;
+            deferredRoots.delete(dr);
+            placedCount++;
+            placedDeferred = true;
+          }
+          if (placedDeferred) {
+            childLevel += 4;
+          }
+        }
         let highestPosition;
         if (edgeDir !== graph.config.graphDirection) {
           highestPosition = edgeDir === "LR" ? gc.y : gc.x;
@@ -3788,6 +3843,30 @@ function createMapping(graph) {
         } else {
           highestPosition = highestPositionPerLevel[childLevel];
         }
+        if (childSg) {
+          const existingSgNodes = childSg.nodes.filter((n) => n !== child && n.gridCoord !== null);
+          if (existingSgNodes.length > 0) {
+            const perpPositions = existingSgNodes.map(
+              (n) => graph.config.graphDirection === "TD" ? n.gridCoord.x : n.gridCoord.y
+            );
+            const sgMinPerp = Math.min(...perpPositions);
+            highestPosition = Math.max(highestPosition, sgMinPerp);
+          } else if (parentSg && parentSg !== childSg) {
+            const parentSgNodes = parentSg.nodes.filter((n) => n.gridCoord !== null);
+            if (parentSgNodes.length > 0) {
+              const parentLevels = parentSgNodes.map(
+                (n) => graph.config.graphDirection === "TD" ? n.gridCoord.y : n.gridCoord.x
+              );
+              const parentMaxLevel = Math.max(...parentLevels) + 2;
+              if (childLevel <= parentMaxLevel) {
+                const maxPerp = Math.max(...parentSgNodes.map(
+                  (n) => graph.config.graphDirection === "TD" ? n.gridCoord.x : n.gridCoord.y
+                ));
+                highestPosition = Math.max(highestPosition, maxPerp + 4);
+              }
+            }
+          }
+        }
         const requested = edgeDir === "LR" ? { x: childLevel, y: highestPosition } : { x: highestPosition, y: childLevel };
         reserveSpotInGrid(graph, graph.nodes[child.index], requested, edgeDir);
         if (edgeDir === graph.config.graphDirection) {