@crazyhappyone/auto-graph 0.1.1 → 0.1.2

package/dist/cli/index.cjs

@@ -3354,6 +3354,51 @@ function routeEdge(input) {
     )
   );
   if (hardClearCandidate !== void 0) {
+    let bestPoints2 = hardClearCandidate.points;
+    if (input.kind === "obstacle-avoiding") {
+      const allObstacles = [...softObstacles, ...hardObstacles];
+      for (const candidate of candidateRoutes) {
+        if (routeCrossesBoxes(candidate.points, hardObstacles) || routeIntersectsEndpointInteriors(
+          candidate.points,
+          candidate.endpointObstacles
+        )) {
+          continue;
+        }
+        const rerouted2 = greedyRerouteAroundObstacles(
+          candidate.points,
+          allObstacles,
+          3
+        );
+        if (!routeCrossesBoxes(rerouted2, allObstacles) && !routeIntersectsEndpointInteriors(
+          rerouted2,
+          candidate.endpointObstacles
+        )) {
+          return {
+            points: finalizeRoute(
+              rerouted2,
+              softObstacles,
+              hardObstacles,
+              diagnostics
+            ),
+            diagnostics
+          };
+        }
+      }
+      const rerouted = greedyRerouteAroundObstacles(
+        bestPoints2,
+        allObstacles,
+        3
+      );
+      const reroutedAvoidsEndpointInteriors = !routeIntersectsEndpointInteriors(
+        rerouted,
+        hardClearCandidate.endpointObstacles
+      );
+      if (reroutedAvoidsEndpointInteriors) {
+        if (routeCrossesBoxes(rerouted, hardObstacles) && !routeCrossesBoxes(bestPoints2, hardObstacles)) ; else {
+          bestPoints2 = rerouted;
+        }
+      }
+    }
     diagnostics.push({
       severity: "warning",
       code: "routing.obstacle.unavoidable",
@@ -3361,7 +3406,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        hardClearCandidate.points,
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3370,6 +3415,33 @@ function routeEdge(input) {
     };
   }
   if (hardObstacles.length > 0) {
+    let bestPoints2 = candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors);
+    if (input.kind === "obstacle-avoiding") {
+      const allObstacles = [...softObstacles, ...hardObstacles];
+      for (const candidate of candidateRoutes) {
+        const rerouted = greedyRerouteAroundObstacles(
+          candidate.points,
+          allObstacles,
+          5
+        );
+        if (!routeCrossesBoxes(rerouted, allObstacles)) {
+          return {
+            points: finalizeRoute(
+              rerouted,
+              softObstacles,
+              hardObstacles,
+              diagnostics
+            ),
+            diagnostics
+          };
+        }
+      }
+      bestPoints2 = greedyRerouteAroundObstacles(
+        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        allObstacles,
+        5
+      );
+    }
     diagnostics.push({
       severity: "error",
       code: "routing.evidence.crossing_forbidden",
@@ -3377,7 +3449,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3385,6 +3457,33 @@ function routeEdge(input) {
       diagnostics
     };
   }
+  let bestPoints = candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors);
+  if (input.kind === "obstacle-avoiding") {
+    const allObstacles = [...softObstacles, ...hardObstacles];
+    for (const candidate of candidateRoutes) {
+      const rerouted = greedyRerouteAroundObstacles(
+        candidate.points,
+        allObstacles,
+        5
+      );
+      if (!routeCrossesBoxes(rerouted, allObstacles)) {
+        return {
+          points: finalizeRoute(
+            rerouted,
+            softObstacles,
+            hardObstacles,
+            diagnostics
+          ),
+          diagnostics
+        };
+      }
+    }
+    bestPoints = greedyRerouteAroundObstacles(
+      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      allObstacles,
+      5
+    );
+  }
   diagnostics.push({
     severity: "warning",
     code: "routing.obstacle.unavoidable",
@@ -3392,7 +3491,7 @@ function routeEdge(input) {
   });
   return {
     points: finalizeRoute(
-      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      bestPoints,
       softObstacles,
       hardObstacles,
       diagnostics
@@ -3550,6 +3649,70 @@ function insetBox(box, margin) {
     height: box.height - margin * 2
   };
 }
+function greedyRerouteAroundObstacles(points, obstacles, maxIterations) {
+  let current = [...points];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const improved = pushRouteAwayFromObstacles(current, obstacles);
+    if (improved === null) {
+      break;
+    }
+    current = improved;
+    if (!routeCrossesBoxes(current, obstacles)) {
+      break;
+    }
+  }
+  return current;
+}
+function pushRouteAwayFromObstacles(points, obstacles) {
+  const result = [];
+  let improved = false;
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    if (a === void 0 || b === void 0) {
+      result.push(a ?? b ?? { x: 0, y: 0 });
+      continue;
+    }
+    result.push(a);
+    const intersectors = obstacles.filter(
+      (obs) => segmentIntersectsBox(a, b, obs)
+    );
+    if (intersectors.length === 0) {
+      continue;
+    }
+    const mx = (a.x + b.x) / 2;
+    const my = (a.y + b.y) / 2;
+    const isHorizontal = a.y === b.y;
+    const margin = 12;
+    let bestWaypoint = null;
+    let bestDist = Infinity;
+    for (const obs of intersectors) {
+      const candidates = isHorizontal ? [
+        { x: mx, y: obs.y - margin },
+        { x: mx, y: obs.y + obs.height + margin }
+      ] : [
+        { x: obs.x - margin, y: my },
+        { x: obs.x + obs.width + margin, y: my }
+      ];
+      for (const wp of candidates) {
+        const dist = Math.hypot(wp.x - mx, wp.y - my);
+        if (dist < bestDist) {
+          bestDist = dist;
+          bestWaypoint = wp;
+        }
+      }
+    }
+    if (bestWaypoint !== null) {
+      result.push(bestWaypoint);
+      improved = true;
+    }
+  }
+  const last = points[points.length - 1];
+  if (last !== void 0) {
+    result.push(last);
+  }
+  return improved ? result : null;
+}
 function fallbackRoute(input, defaultAnchors) {
   return [
     getEdgePort(
@@ -4136,7 +4299,9 @@ function solveDiagram(diagram, options = {}) {
     styledEdges,
     nodeGeometryById,
     coordinatedNodes,
-    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
+    [...nodeGeometryById.values()].map(
+      (geometry) => options.routingGutter === void 0 ? geometry.obstacleBox : expandBox(geometry.obstacleBox, options.routingGutter)
+    ),
     [...softObstacles, ...titleBarObstacles],
     routingTextObstacles,
     hardObstacles,
@@ -6456,9 +6621,7 @@ function edgeLabelAnchorCandidates(points, placement, layout2) {
         { x: placement.x, y: placement.y + offset }
       );
     }
-    return candidates;
-  }
-  if (segment.start.x === segment.end.x) {
+  } else if (segment.start.x === segment.end.x) {
     const needed = layout2.box.width / 2 + EDGE_LABEL_CLEARANCE;
     const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
     for (let step = 1; step <= maxSteps; step += 1) {
@@ -6468,7 +6631,83 @@ function edgeLabelAnchorCandidates(points, placement, layout2) {
         { x: placement.x - offset, y: placement.y }
       );
     }
-    return candidates;
+  } else {
+    const dx = segment.end.x - segment.start.x;
+    const dy = segment.end.y - segment.start.y;
+    const segLen = Math.hypot(dx, dy);
+    if (segLen > 0) {
+      const nx = -dy / segLen;
+      const ny = dx / segLen;
+      const needed = (Math.abs(nx) * layout2.box.width + Math.abs(ny) * layout2.box.height) / 2 + EDGE_LABEL_CLEARANCE;
+      const maxSteps = Math.max(12, Math.ceil(needed / EDGE_LABEL_CLEARANCE));
+      for (let step = 1; step <= maxSteps; step += 1) {
+        const offset = EDGE_LABEL_CLEARANCE * step;
+        candidates.push(
+          { x: placement.x + nx * offset, y: placement.y + ny * offset },
+          { x: placement.x - nx * offset, y: placement.y - ny * offset }
+        );
+      }
+    }
+  }
+  const totalLen = points.reduce((sum, p, idx) => {
+    if (idx === 0) return 0;
+    const prev = points[idx - 1];
+    return sum + Math.hypot((p?.x ?? 0) - (prev?.x ?? 0), (p?.y ?? 0) - (prev?.y ?? 0));
+  }, 0);
+  if (totalLen > 200) {
+    for (const ratio of [0.25, 0.75]) {
+      const qp = labelPlacementAtRatio(points, ratio, totalLen);
+      if (qp !== void 0) {
+        candidates.push(qp);
+        const qTargetDist = totalLen * ratio;
+        let qTravelled = 0;
+        let seg;
+        for (let si = 1; si < points.length; si++) {
+          const sp = points[si - 1];
+          const sc = points[si];
+          if (sp === void 0 || sc === void 0) continue;
+          const sl = Math.hypot(sc.x - sp.x, sc.y - sp.y);
+          if (sl <= 0) continue;
+          if (qTravelled + sl >= qTargetDist) {
+            seg = { start: sp, end: sc, length: sl };
+            break;
+          }
+          qTravelled += sl;
+        }
+        if (seg !== void 0) {
+          const segLen = Math.hypot(
+            seg.end.x - seg.start.x,
+            seg.end.y - seg.start.y
+          );
+          const qpNeeded = seg.start.y === seg.end.y ? layout2.box.height / 2 + EDGE_LABEL_CLEARANCE : seg.start.x === seg.end.x ? layout2.box.width / 2 + EDGE_LABEL_CLEARANCE : (Math.abs(seg.start.y - seg.end.y) * layout2.box.width + Math.abs(seg.end.x - seg.start.x) * layout2.box.height) / (2 * segLen) + EDGE_LABEL_CLEARANCE;
+          const qpMaxSteps = Math.max(
+            12,
+            Math.ceil(qpNeeded / EDGE_LABEL_CLEARANCE)
+          );
+          for (let step = 1; step <= qpMaxSteps; step += 1) {
+            const offset = EDGE_LABEL_CLEARANCE * step;
+            if (seg.start.y === seg.end.y) {
+              candidates.push(
+                { x: qp.x, y: qp.y - offset },
+                { x: qp.x, y: qp.y + offset }
+              );
+            } else if (seg.start.x === seg.end.x) {
+              candidates.push(
+                { x: qp.x - offset, y: qp.y },
+                { x: qp.x + offset, y: qp.y }
+              );
+            } else {
+              const nx = -(seg.end.y - seg.start.y) / segLen;
+              const ny = (seg.end.x - seg.start.x) / segLen;
+              candidates.push(
+                { x: qp.x + nx * offset, y: qp.y + ny * offset },
+                { x: qp.x - nx * offset, y: qp.y - ny * offset }
+              );
+            }
+          }
+        }
+      }
+    }
   }
   return candidates;
 }
@@ -6525,6 +6764,34 @@ function nonZeroSegments2(points) {
   }
   return segments;
 }
+function labelPlacementAtRatio(points, ratio, totalLength) {
+  if (points.length < 2 || ratio < 0 || ratio > 1) {
+    return void 0;
+  }
+  const targetDist = totalLength * ratio;
+  let travelled = 0;
+  for (let idx = 1; idx < points.length; idx++) {
+    const prev = points[idx - 1];
+    const curr = points[idx];
+    if (prev === void 0 || curr === void 0) {
+      continue;
+    }
+    const segLen = Math.hypot(curr.x - prev.x, curr.y - prev.y);
+    if (segLen <= 0) {
+      continue;
+    }
+    if (travelled + segLen >= targetDist) {
+      const t = (targetDist - travelled) / segLen;
+      const offset = labelOffset2({ start: prev, end: curr, length: segLen });
+      return {
+        x: prev.x + (curr.x - prev.x) * t + offset.x,
+        y: prev.y + (curr.y - prev.y) * t + offset.y
+      };
+    }
+    travelled += segLen;
+  }
+  return void 0;
+}
 function labelOffset2(segment) {
   const offset = 10;
   const dx = segment.end.x - segment.start.x;
@@ -6638,7 +6905,7 @@ function isValidEdgeId(value) {
   return value.length > 0 && EDGE_ID_PATTERN.test(value);
 }
 var directionSchema = zod.z.enum(["TB", "LR", "BT", "RL"]);
-var routeKindSchema = zod.z.enum(["orthogonal", "straight"]);
+var routeKindSchema = zod.z.enum(["orthogonal", "straight", "obstacle-avoiding"]);
 var outputFormatSchema = zod.z.enum(["svg", "excalidraw"]);
 var edgeStrokeStyleSchema = zod.z.enum(["solid", "dashed"]);
 var edgeArrowheadSchema = zod.z.enum(["triangle", "hollowTriangle"]);
@@ -7237,7 +7504,7 @@ function renderDiagramDsl(source, options = {}) {
     return { diagnostics };
   }
   const solved = solveDiagram(normalized.diagram, {
-    routeKind: normalized.diagram.metadata?.routeKind === "straight" ? "straight" : "orthogonal",
+    routeKind: normalized.diagram.metadata?.routeKind === "straight" ? "straight" : normalized.diagram.metadata?.routeKind === "obstacle-avoiding" ? "obstacle-avoiding" : "orthogonal",
     ...solvePortShiftingOption(normalized.diagram.metadata?.portShifting),
     ...options.textMeasurer === void 0 ? {} : { textMeasurer: options.textMeasurer }
   });