@ktrysmt/beautiful-mermaid 1.5.0 → 1.5.2

package/dist/index.js

@@ -481,8 +481,43 @@ function parseFlowchart(lines) {
     }
     parseEdgeLine(line, graph, subgraphStack);
   }
+  resolveSubgraphEdgeEndpoints(graph);
   return graph;
 }
+function resolveSubgraphEdgeEndpoints(graph) {
+  const representatives = /* @__PURE__ */ new Map();
+  function pickRepresentative(sg) {
+    for (const id of sg.nodeIds) {
+      if (graph.nodes.has(id)) return id;
+    }
+    for (const child of sg.children) {
+      const childRep = representatives.get(child.id) ?? pickRepresentative(child);
+      if (childRep) return childRep;
+    }
+    return void 0;
+  }
+  function visit(sg) {
+    for (const child of sg.children) visit(child);
+    const rep = pickRepresentative(sg);
+    if (rep) representatives.set(sg.id, rep);
+  }
+  for (const sg of graph.subgraphs) visit(sg);
+  if (representatives.size === 0) return;
+  for (const edge of graph.edges) {
+    const newSource = representatives.get(edge.source);
+    if (newSource) edge.source = newSource;
+    const newTarget = representatives.get(edge.target);
+    if (newTarget) edge.target = newTarget;
+  }
+  for (const sgId of representatives.keys()) {
+    graph.nodes.delete(sgId);
+  }
+  function scrubMembership(sg) {
+    sg.nodeIds = sg.nodeIds.filter((id) => !representatives.has(id));
+    for (const child of sg.children) scrubMembership(child);
+  }
+  for (const sg of graph.subgraphs) scrubMembership(sg);
+}
 function parseStateDiagram(lines) {
   const graph = {
     direction: "TD",
@@ -3912,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);
@@ -3922,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) {
@@ -4073,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);
 }