@ktrysmt/beautiful-mermaid 1.4.2 → 1.4.3

package/dist/index.js

@@ -263,8 +263,11 @@ function measureMultilineText(text, fontSize, fontWeight) {
 
 // src/multiline-utils.ts
 function normalizeBrTags(label) {
-  const unquoted = label.startsWith('"') && label.endsWith('"') ? label.slice(1, -1) : label;
-  return unquoted.replace(/<br\s*\/?>/gi, "\n").replace(/\\n/g, "\n").replace(/<\/?(?:sub|sup|small|mark)\s*>/gi, "").replace(/\*\*(.+?)\*\*/g, "<b>$1</b>").replace(/(?<!\*)\*([^\s*](?:[^*]*[^\s*])?)\*(?!\*)/g, "<i>$1</i>").replace(/~~(.+?)~~/g, "<s>$1</s>");
+  let result = label.replace(/<br\s*\/?>/gi, "\n").replace(/\\n/g, "\n").trim();
+  if (result.startsWith('"') && result.endsWith('"')) {
+    result = result.slice(1, -1);
+  }
+  return result.replace(/<\/?(?:sub|sup|small|mark)\s*>/gi, "").replace(/\*\*(.+?)\*\*/g, "<b>$1</b>").replace(/(?<!\*)\*([^\s*](?:[^*]*[^\s*])?)\*(?!\*)/g, "<i>$1</i>").replace(/~~(.+?)~~/g, "<s>$1</s>").trim();
 }
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -336,8 +339,43 @@ ${textEl}`;
 }
 
 // src/parser.ts
+function joinMultilineDefinitions(lines) {
+  const result = [];
+  let buffer = "";
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  let inQuote = false;
+  for (const line of lines) {
+    if (bracketDepth === 0 && parenDepth === 0 && !inQuote) {
+      buffer = line;
+    } else {
+      if (/<br\s*\/?>\s*$/i.test(buffer)) {
+        buffer += line;
+      } else {
+        buffer += "<br>" + line;
+      }
+    }
+    for (const ch of line) {
+      if (ch === '"') {
+        inQuote = !inQuote;
+      } else if (!inQuote) {
+        if (ch === "[") bracketDepth++;
+        else if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+        else if (ch === "(") parenDepth++;
+        else if (ch === ")") parenDepth = Math.max(0, parenDepth - 1);
+      }
+    }
+    if (bracketDepth === 0 && parenDepth === 0 && !inQuote) {
+      result.push(buffer);
+      buffer = "";
+    }
+  }
+  if (buffer) result.push(buffer);
+  return result;
+}
 function parseMermaid(text) {
-  const lines = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("%%"));
+  const rawLines = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("%%"));
+  const lines = joinMultilineDefinitions(rawLines);
   if (lines.length === 0) {
     throw new Error("Empty mermaid diagram");
   }
@@ -1691,7 +1729,7 @@ function isFreeInGrid(grid, c) {
   return !grid.has(gridKey(c));
 }
 var MAX_ITERATIONS = 5e4;
-function getPath(grid, from, to) {
+function getPath(grid, from, to, congestion) {
   const pq = new MinHeap();
   pq.push({ coord: from, priority: 0 });
   const costSoFar = /* @__PURE__ */ new Map();
@@ -1719,7 +1757,8 @@ function getPath(grid, from, to) {
       if (!isFreeInGrid(grid, next) && !gridCoordEquals(next, to)) {
         continue;
       }
-      const newCost = currentCost + 1;
+      const congestionPenalty = congestion?.get(gridKey(next)) ?? 0;
+      const newCost = currentCost + 1 + congestionPenalty * 3;
       const nextKey = gridKey(next);
       const existingCost = costSoFar.get(nextKey);
       if (existingCost === void 0 || newCost < existingCost) {
@@ -1863,17 +1902,17 @@ function determineStartAndEndDir(edge, graphDirection) {
   }
   return [preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir];
 }
-function determinePath(graph, edge) {
+function determinePath(graph, edge, congestion) {
   const sourceSg = getNodeSubgraph(graph, edge.from);
   const targetSg = getNodeSubgraph(graph, edge.to);
   const effectiveDir = sourceSg && sourceSg === targetSg && sourceSg.direction ? sourceSg.direction : graph.config.graphDirection;
   const [preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir] = determineStartAndEndDir(edge, effectiveDir);
   const prefFrom = gridCoordDirection(edge.from.gridCoord, preferredDir);
   const prefTo = gridCoordDirection(edge.to.gridCoord, preferredOppositeDir);
-  let preferredPath = getPath(graph.grid, prefFrom, prefTo);
+  let preferredPath = getPath(graph.grid, prefFrom, prefTo, congestion);
   const altFrom = gridCoordDirection(edge.from.gridCoord, alternativeDir);
   const altTo = gridCoordDirection(edge.to.gridCoord, alternativeOppositeDir);
-  let alternativePath = getPath(graph.grid, altFrom, altTo);
+  let alternativePath = getPath(graph.grid, altFrom, altTo, congestion);
   if (preferredPath !== null && alternativePath !== null) {
     preferredPath = mergePath(preferredPath);
     alternativePath = mergePath(alternativePath);
@@ -1904,11 +1943,41 @@ function determinePath(graph, edge) {
   edge.endDir = preferredOppositeDir;
   edge.path = [prefFrom, prefTo];
 }
+function pathToCells(path) {
+  const cells = [];
+  for (let i = 0; i < path.length - 1; i++) {
+    const p1 = path[i];
+    const p2 = path[i + 1];
+    if (p1.x === p2.x) {
+      const minY = Math.min(p1.y, p2.y);
+      const maxY = Math.max(p1.y, p2.y);
+      for (let y = minY; y <= maxY; y++) {
+        cells.push({ x: p1.x, y });
+      }
+    } else {
+      const minX = Math.min(p1.x, p2.x);
+      const maxX = Math.max(p1.x, p2.x);
+      for (let x = minX; x <= maxX; x++) {
+        cells.push({ x, y: p1.y });
+      }
+    }
+  }
+  return cells;
+}
+function segmentMidpointKey(line) {
+  const isVertical = line[0].x === line[1].x;
+  if (isVertical) {
+    const mid = Math.floor((line[0].y + line[1].y) / 2);
+    return `v:${line[0].x}:${mid}`;
+  } else {
+    const mid = Math.floor((line[0].x + line[1].x) / 2);
+    return `h:${line[0].y}:${mid}`;
+  }
+}
 function determineLabelLine(graph, edge) {
   if (edge.text.length === 0) return;
   const lenLabel = maxLineWidth(edge.text);
   const pathLen = edge.path.length;
-  const isVerticalFlow = graph.config.graphDirection === "TD";
   const segments = [];
   for (let i = 1; i < pathLen; i++) {
     const p1 = edge.path[i - 1];
@@ -1918,21 +1987,26 @@ function determineLabelLine(graph, edge) {
     const isVertical = p1.x === p2.x;
     segments.push({ line, width, index: i, isVertical });
   }
-  const suitableSegments = segments.filter((s) => s.width >= lenLabel && s.index > 1);
+  const used = graph.usedLabelMidpoints ?? /* @__PURE__ */ new Set();
+  const middleIdx = Math.floor(pathLen / 2);
+  const scoreSeg = (s) => {
+    const key = segmentMidpointKey(s.line);
+    let score = 0;
+    if (!used.has(key)) score += 1e3;
+    if (s.index > 1) score += 100;
+    score -= Math.abs(s.index - middleIdx);
+    return score;
+  };
+  const candidates = segments.filter((s) => s.width >= lenLabel);
   let largestLine;
-  if (suitableSegments.length > 0) {
-    suitableSegments.sort((a, b) => b.index - a.index);
-    largestLine = suitableSegments[0].line;
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => scoreSeg(b) - scoreSeg(a));
+    largestLine = candidates[0].line;
   } else {
-    const fallbackSegments = segments.filter((s) => s.width >= lenLabel);
-    if (fallbackSegments.length > 0) {
-      fallbackSegments.sort((a, b) => b.index - a.index);
-      largestLine = fallbackSegments[0].line;
-    } else {
-      segments.sort((a, b) => b.width - a.width);
-      largestLine = segments[0]?.line ?? [edge.path[0], edge.path[1]];
-    }
+    segments.sort((a, b) => b.width - a.width);
+    largestLine = segments[0]?.line ?? [edge.path[0], edge.path[1]];
   }
+  used.add(segmentMidpointKey(largestLine));
   const minX = Math.min(largestLine[0].x, largestLine[1].x);
   const maxX = Math.max(largestLine[0].x, largestLine[1].x);
   const middleX = minX + Math.floor((maxX - minX) / 2);
@@ -3815,7 +3889,14 @@ 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;
-        let childLevel = edgeDir === "LR" ? gc.x + 4 : gc.y + 4;
+        let maxPredLevel = edgeDir === "LR" ? gc.x : gc.y;
+        for (const e of graph.edges) {
+          if (e.to.name === child.name && e.from.gridCoord !== null) {
+            const predLevel = edgeDir === "LR" ? e.from.gridCoord.x : e.from.gridCoord.y;
+            if (predLevel > maxPredLevel) maxPredLevel = predLevel;
+          }
+        }
+        let childLevel = maxPredLevel + 4;
         if (childSg && parentSg !== childSg && deferredRoots.size > 0) {
           let placedDeferred = false;
           for (const dr of [...deferredRoots]) {
@@ -3880,17 +3961,44 @@ function createMapping(graph) {
   for (const node of graph.nodes) {
     setColumnWidth(graph, node);
   }
+  const labeledInDegree = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.text.length > 0) {
+      labeledInDegree.set(edge.to.name, (labeledInDegree.get(edge.to.name) ?? 0) + 1);
+    }
+  }
+  for (const node of graph.nodes) {
+    const deg = labeledInDegree.get(node.name) ?? 0;
+    if (deg >= 3 && node.gridCoord) {
+      const approachRow = node.gridCoord.y - 1;
+      if (approachRow >= 0) {
+        const extra = Math.min((deg - 2) * 2, 10);
+        const current = graph.rowHeight.get(approachRow) ?? 0;
+        graph.rowHeight.set(approachRow, Math.max(current, current + extra));
+      }
+    }
+  }
   graph.bundles = analyzeEdgeBundles(graph);
   processBundles(graph);
+  graph.usedLabelMidpoints = /* @__PURE__ */ new Set();
+  const congestion = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
     if (edge.bundle && edge.path.length > 0) {
       increaseGridSizeForPath(graph, edge.path);
       determineLabelLine(graph, edge);
+      for (const cell of pathToCells(edge.path)) {
+        const k = gridKey(cell);
+        congestion.set(k, (congestion.get(k) ?? 0) + 1);
+      }
       continue;
     }
-    determinePath(graph, edge);
+    determinePath(graph, edge, congestion);
     increaseGridSizeForPath(graph, edge.path);
     determineLabelLine(graph, edge);
+    for (const cell of pathToCells(edge.path)) {
+      const k = gridKey(cell);
+      congestion.set(k, (congestion.get(k) ?? 0) + 1);
+    }
   }
   for (const node of graph.nodes) {
     node.drawingCoord = gridToDrawingCoord(graph, node.gridCoord);