@ktrysmt/beautiful-mermaid 1.5.1 → 1.5.2

package/dist/index.js

@@ -3947,6 +3947,7 @@ function createMapping(graph) {
       primaryRoots.push(root);
     }
   }
+  const sourceStartLevel = computeSourceStartLevels(graph, primaryRoots);
   const rootsByTarget = /* @__PURE__ */ new Map();
   for (const root of primaryRoots) {
     const children = getChildren(graph, root);
@@ -3957,9 +3958,10 @@ function createMapping(graph) {
   }
   for (const [, roots] of rootsByTarget) {
     for (const node of roots) {
-      const requested = dir === "LR" ? { x: 0, y: highestPositionPerLevel[0] } : { x: highestPositionPerLevel[0], y: 0 };
+      const startLevel = sourceStartLevel.get(node.name) ?? 0;
+      const requested = dir === "LR" ? { x: startLevel, y: highestPositionPerLevel[startLevel] } : { x: highestPositionPerLevel[startLevel], y: startLevel };
       reserveSpotInGrid(graph, graph.nodes[node.index], requested);
-      highestPositionPerLevel[0] = highestPositionPerLevel[0] + 4;
+      highestPositionPerLevel[startLevel] = highestPositionPerLevel[startLevel] + 4;
     }
   }
   if (shouldSeparate && subgraphRootNodes.length > 0) {
@@ -4108,6 +4110,62 @@ function createMapping(graph) {
 function getEdgesFromNode(graph, node) {
   return graph.edges.filter((e) => e.from.name === node.name);
 }
+function computeSourceStartLevels(graph, sources) {
+  const childrenByName = /* @__PURE__ */ new Map();
+  const parentsByName = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) {
+    childrenByName.set(n.name, []);
+    parentsByName.set(n.name, []);
+    inDegree.set(n.name, 0);
+  }
+  for (const e of graph.edges) {
+    if (e.from.name === e.to.name) continue;
+    childrenByName.get(e.from.name).push(e.to);
+    parentsByName.get(e.to.name).push(e.from);
+    inDegree.set(e.to.name, (inDegree.get(e.to.name) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const n of graph.nodes) {
+    if ((inDegree.get(n.name) ?? 0) === 0) queue.push(n);
+  }
+  const topoOrder = [];
+  while (queue.length > 0) {
+    const n = queue.shift();
+    topoOrder.push(n);
+    for (const c of childrenByName.get(n.name) ?? []) {
+      const d = (inDegree.get(c.name) ?? 0) - 1;
+      inDegree.set(c.name, d);
+      if (d === 0) queue.push(c);
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  if (topoOrder.length < graph.nodes.length) return result;
+  const forwardLevel = /* @__PURE__ */ new Map();
+  for (const n of topoOrder) {
+    let best = 0;
+    for (const p of parentsByName.get(n.name) ?? []) {
+      const pl = (forwardLevel.get(p.name) ?? 0) + 1;
+      if (pl > best) best = pl;
+    }
+    forwardLevel.set(n.name, best);
+  }
+  for (const src of sources) {
+    const children = getChildren(graph, src).filter((c) => c.name !== src.name);
+    if (children.length === 0) {
+      result.set(src.name, 0);
+      continue;
+    }
+    let minChild = Infinity;
+    for (const c of children) {
+      const cl = forwardLevel.get(c.name) ?? 0;
+      if (cl < minChild) minChild = cl;
+    }
+    const logical = Number.isFinite(minChild) ? Math.max(0, minChild - 1) : 0;
+    result.set(src.name, logical * 4);
+  }
+  return result;
+}
 function getChildren(graph, node) {
   return getEdgesFromNode(graph, node).map((e) => e.to);
 }