@markdy/core 1.4.1 → 1.4.3

package/dist/index.js

@@ -1023,17 +1023,32 @@ function dedupeEdges(edges) {
 function assignRanks(nodeIds, edges, direction) {
   const ranks = /* @__PURE__ */ new Map();
   for (const id of nodeIds) ranks.set(id, 0);
-  const forward = edges.filter((e) => e.kind !== "response" && !e.selfLoop);
-  for (let sweep = 0; sweep < nodeIds.length; sweep++) {
-    let changed = false;
-    for (const e of forward) {
-      const next = (ranks.get(e.from) ?? 0) + 1;
-      if (next > (ranks.get(e.to) ?? 0)) {
-        ranks.set(e.to, next);
-        changed = true;
-      }
+  const outgoing = new Map(nodeIds.map((id) => [id, []]));
+  const indegree = new Map(nodeIds.map((id) => [id, 0]));
+  for (const edge of edges) {
+    if (edge.kind === "response" || edge.selfLoop || !outgoing.has(edge.from) || !outgoing.has(edge.to)) continue;
+    outgoing.get(edge.from).push(edge.to);
+    indegree.set(edge.to, indegree.get(edge.to) + 1);
+  }
+  const queue = nodeIds.filter((id) => indegree.get(id) === 0);
+  const processed = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  let cycleRoot = 0;
+  while (processed.size < nodeIds.length) {
+    if (cursor === queue.length) {
+      while (processed.has(nodeIds[cycleRoot])) cycleRoot++;
+      queue.push(nodeIds[cycleRoot]);
+    }
+    const id = queue[cursor++];
+    if (processed.has(id)) continue;
+    processed.add(id);
+    for (const target of outgoing.get(id)) {
+      if (processed.has(target)) continue;
+      ranks.set(target, Math.max(ranks.get(target), ranks.get(id) + 1));
+      const remaining = indegree.get(target) - 1;
+      indegree.set(target, remaining);
+      if (remaining === 0) queue.push(target);
     }
-    if (!changed) break;
   }
   if (direction === "RL" || direction === "BT") {
     const max = Math.max(...ranks.values(), 0);
@@ -1047,7 +1062,7 @@ function snapGrid(n, step = 4) {
 function layoutRanked(ast, edges, opts) {
   const nodeIds = Object.keys(ast.nodes);
   const dtype = diagramType(ast);
-  const direction = opts.forceVertical ? "TB" : ast.meta.direction;
+  const direction = opts.forceVertical ? ast.meta.direction === "BT" ? "BT" : "TB" : ast.meta.direction;
   const ranks = assignRanks(nodeIds, edges, direction);
   const byRank = /* @__PURE__ */ new Map();
   for (const id of nodeIds) {
@@ -1072,6 +1087,7 @@ function layoutRanked(ast, edges, opts) {
   }
   const rankOrder = /* @__PURE__ */ new Map();
   const sortedRanks = [...byRank.keys()].sort((a, b) => a - b);
+  if (direction === "RL" || direction === "BT") sortedRanks.reverse();
   for (const r of sortedRanks) {
     const ids = byRank.get(r);
     ids.sort((a, b) => {
@@ -1091,6 +1107,39 @@ function layoutRanked(ast, edges, opts) {
       rankOrder.set(id, idx);
     });
   }
+  const neighbors = new Map(nodeIds.map((id) => [id, []]));
+  for (const edge of edges) {
+    if (edge.kind === "response" || edge.selfLoop || !neighbors.has(edge.from) || !neighbors.has(edge.to)) continue;
+    neighbors.get(edge.from).push(edge.to);
+    neighbors.get(edge.to).push(edge.from);
+  }
+  for (let sweep = 0; sweep < 4; sweep++) {
+    let changed = false;
+    const order = sweep % 2 === 0 ? [...sortedRanks].reverse() : sortedRanks;
+    for (const rank of order) {
+      const ids = byRank.get(rank);
+      for (let index = 0; index < ids.length - 1; index++) {
+        const left = ids[index];
+        const right = ids[index + 1];
+        if (nodeGroupIndex.get(left) !== nodeGroupIndex.get(right)) continue;
+        let improvement = 0;
+        for (const leftNeighbor of neighbors.get(left)) {
+          for (const rightNeighbor of neighbors.get(right)) {
+            const neighborRank = ranks.get(leftNeighbor);
+            if (neighborRank === rank || neighborRank !== ranks.get(rightNeighbor)) continue;
+            improvement += Math.sign(rankOrder.get(leftNeighbor) - rankOrder.get(rightNeighbor));
+          }
+        }
+        if (improvement <= 0) continue;
+        ids[index] = right;
+        ids[index + 1] = left;
+        rankOrder.set(right, index);
+        rankOrder.set(left, index + 1);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
   const isVertical = direction === "TB" || direction === "BT";
   const hasTitle = Boolean(ast.meta.title && ast.meta.title.trim().length > 0);
   const hasBeatCaptions = ast.beats.some((b) => b.label && b.label.trim().length > 0);
@@ -1225,6 +1274,7 @@ function layoutRanked(ast, edges, opts) {
 function layoutTree(ast, edges) {
   const nodeIds = Object.keys(ast.nodes);
   if (nodeIds.length === 0) return [];
+  edges = cycleSafeEdges(nodeIds, edges);
   const nodeDims = /* @__PURE__ */ new Map();
   for (const id of nodeIds) {
     nodeDims.set(id, computeNodeDimensions(ast.nodes[id]));
@@ -1395,19 +1445,21 @@ function cycleSafeEdges(nodeIds, edges) {
   }
   const visited = /* @__PURE__ */ new Set();
   const safe = [];
-  const visit = (id) => {
-    if (visited.has(id)) return;
-    visited.add(id);
-    for (const edge of outgoing.get(id) ?? []) {
-      if (visited.has(edge.to)) continue;
-      safe.push(edge);
-      visit(edge.to);
+  const roots = nodeIds.filter((id) => !incoming.has(id));
+  for (const root of [...roots, ...nodeIds]) {
+    if (visited.has(root)) continue;
+    const stack = [{ id: root }];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (visited.has(current.id)) continue;
+      visited.add(current.id);
+      if (current.edge) safe.push(current.edge);
+      const children = outgoing.get(current.id);
+      for (let index = children.length - 1; index >= 0; index--) {
+        stack.push({ id: children[index].to, edge: children[index] });
+      }
     }
-  };
-  for (const id of nodeIds) {
-    if (!incoming.has(id)) visit(id);
   }
-  for (const id of nodeIds) visit(id);
   return safe;
 }
 function layoutConstellation(ast) {
@@ -2549,7 +2601,8 @@ function computeAdaptiveDimensions(ast, edges) {
     const children = /* @__PURE__ */ new Map();
     const hasParent = /* @__PURE__ */ new Set();
     for (const id of nodeIds) children.set(id, []);
-    const treeEdges = effectiveEdges.some((e) => e.structural) ? effectiveEdges.filter((e) => e.structural) : effectiveEdges;
+    const treeCandidates = effectiveEdges.some((e) => e.structural) ? effectiveEdges.filter((e) => e.structural) : effectiveEdges;
+    const treeEdges = cycleSafeEdges(nodeIds, treeCandidates);
     for (const e of treeEdges) {
       if (ast.nodes[e.from] && ast.nodes[e.to] && e.from !== e.to) {
         children.get(e.from)?.push(e.to);
@@ -5257,6 +5310,97 @@ function buildSmoothSvgPath(start, waypoints, end, cornerRadius = 0) {
   d += ` L ${end.x} ${end.y}`;
   return d;
 }
+function routeAroundObstacles(sourceBox, targetBox, points, options) {
+  if (!options.obstacles?.length) return points;
+  const margin = options.margin ?? 20;
+  const obstacles = [sourceBox, targetBox, ...options.obstacles];
+  const intersections = (route) => {
+    let hits = 0;
+    for (let index = 1; index < route.length; index++) {
+      const start2 = route[index - 1];
+      const end2 = route[index];
+      if (start2.x === end2.x && start2.y === end2.y) continue;
+      for (const box of obstacles) {
+        if (start2.y === end2.y && start2.y > box.y && start2.y < box.y + box.height && Math.max(start2.x, end2.x) > box.x && Math.min(start2.x, end2.x) < box.x + box.width) hits++;
+        else if (start2.x === end2.x && start2.x > box.x && start2.x < box.x + box.width && Math.max(start2.y, end2.y) > box.y && Math.min(start2.y, end2.y) < box.y + box.height) hits++;
+      }
+    }
+    return hits;
+  };
+  if (intersections(points) === 0) return points;
+  const start = points[0];
+  const end = points[points.length - 1];
+  const stub = (point, port) => {
+    let distance = margin;
+    for (const box of obstacles) {
+      let clearance = Number.POSITIVE_INFINITY;
+      if (point.y > box.y && point.y < box.y + box.height) {
+        if (port === "right") clearance = box.x - point.x;
+        if (port === "left") clearance = point.x - box.x - box.width;
+      }
+      if (point.x > box.x && point.x < box.x + box.width) {
+        if (port === "bottom") clearance = box.y - point.y;
+        if (port === "top") clearance = point.y - box.y - box.height;
+      }
+      if (clearance >= 0) distance = Math.min(distance, clearance / 2);
+    }
+    return {
+      x: point.x + (port === "right" ? distance : port === "left" ? -distance : 0),
+      y: point.y + (port === "bottom" ? distance : port === "top" ? -distance : 0)
+    };
+  };
+  const sourceStub = stub(start, options.sourcePort);
+  const targetStub = stub(end, options.targetPort);
+  const corridorsX = /* @__PURE__ */ new Set();
+  const corridorsY = /* @__PURE__ */ new Set();
+  for (const box of obstacles) {
+    corridorsX.add(box.x - margin);
+    corridorsX.add(box.x + box.width + margin);
+    corridorsY.add(box.y - margin);
+    corridorsY.add(box.y + box.height + margin);
+  }
+  const candidates = [
+    points,
+    [start, sourceStub, { x: sourceStub.x, y: targetStub.y }, targetStub, end],
+    [start, sourceStub, { x: targetStub.x, y: sourceStub.y }, targetStub, end]
+  ];
+  for (const corridor of corridorsX) {
+    candidates.push([
+      start,
+      sourceStub,
+      { x: corridor, y: sourceStub.y },
+      { x: corridor, y: targetStub.y },
+      targetStub,
+      end
+    ]);
+  }
+  for (const corridor of corridorsY) {
+    candidates.push([
+      start,
+      sourceStub,
+      { x: sourceStub.x, y: corridor },
+      { x: targetStub.x, y: corridor },
+      targetStub,
+      end
+    ]);
+  }
+  let best = points;
+  let bestHits = Number.POSITIVE_INFINITY;
+  let bestLength = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const hits = intersections(candidate);
+    let length = 0;
+    for (let index = 1; index < candidate.length; index++) {
+      length += Math.abs(candidate[index].x - candidate[index - 1].x) + Math.abs(candidate[index].y - candidate[index - 1].y);
+    }
+    if (hits < bestHits || hits === bestHits && length < bestLength) {
+      best = candidate;
+      bestHits = hits;
+      bestLength = length;
+    }
+  }
+  return best.filter((point, index) => index === 0 || point.x !== best[index - 1].x || point.y !== best[index - 1].y);
+}
 function routeOrthogonalEdge(sourceBox, targetBox, options = {}) {
   const isSelfLoop = sourceBox === targetBox || sourceBox.x === targetBox.x && sourceBox.y === targetBox.y && sourceBox.width === targetBox.width && sourceBox.height === targetBox.height;
   const MARGIN = options.margin ?? 20;
@@ -5299,6 +5443,11 @@ function routeOrthogonalEdge(sourceBox, targetBox, options = {}) {
       end2 = { x: rightX, y: endY };
       waypoints2 = [{ x: apexX, y: startY }, { x: apexX, y: endY }];
     }
+    waypoints2 = routeAroundObstacles(sourceBox, targetBox, [start2, ...waypoints2, end2], {
+      ...options,
+      sourcePort: port,
+      targetPort: port
+    }).slice(1, -1);
     const svgPathData2 = buildSmoothSvgPath(start2, waypoints2, end2, options.cornerRadius ?? 6);
     return {
       sourcePort: port,
@@ -5381,13 +5530,18 @@ function routeOrthogonalEdge(sourceBox, targetBox, options = {}) {
     }
     waypoints.push(p2);
   }
-  const svgPathData = buildSmoothSvgPath(start, waypoints, end, options.cornerRadius ?? 6);
+  const routedWaypoints = routeAroundObstacles(sourceBox, targetBox, [start, ...waypoints, end], {
+    ...options,
+    sourcePort,
+    targetPort
+  }).slice(1, -1);
+  const svgPathData = buildSmoothSvgPath(start, routedWaypoints, end, options.cornerRadius ?? 6);
   return {
     sourcePort,
     targetPort,
     startPoint: start,
     endPoint: end,
-    waypoints,
+    waypoints: routedWaypoints,
     svgPathData
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markdy/core",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Diagram-native MarkdyScript parser and compiler (auto-layout, edge routing, cue scheduling) — zero runtime dependencies.",
   "license": "MIT",
   "type": "module",