@crazyhappyone/auto-graph 0.1.1 → 0.1.3

package/dist/cli/index.js

@@ -3256,6 +3256,7 @@ function routeEdge(input) {
   const diagnostics = [];
   const softObstacles = input.obstacles ?? [];
   const hardObstacles = input.hardObstacles ?? [];
+  const maxAttempts = input.maxRoutingAttempts ?? 5;
   const defaultAnchors = defaultAnchorsForGeometry(
     input.source.box,
     input.target.box,
@@ -3351,6 +3352,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,
+          maxAttempts
+        );
+        if (!routeCrossesBoxes(rerouted2, allObstacles) && !routeIntersectsEndpointInteriors(
+          rerouted2,
+          candidate.endpointObstacles
+        )) {
+          return {
+            points: finalizeRoute(
+              rerouted2,
+              softObstacles,
+              hardObstacles,
+              diagnostics
+            ),
+            diagnostics
+          };
+        }
+      }
+      const rerouted = greedyRerouteAroundObstacles(
+        bestPoints2,
+        allObstacles,
+        Math.min(maxAttempts, 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",
@@ -3358,7 +3404,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        hardClearCandidate.points,
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3367,6 +3413,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,
+          maxAttempts
+        );
+        if (!routeCrossesBoxes(rerouted, allObstacles)) {
+          return {
+            points: finalizeRoute(
+              rerouted,
+              softObstacles,
+              hardObstacles,
+              diagnostics
+            ),
+            diagnostics
+          };
+        }
+      }
+      bestPoints2 = greedyRerouteAroundObstacles(
+        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        allObstacles,
+        maxAttempts
+      );
+    }
     diagnostics.push({
       severity: "error",
       code: "routing.evidence.crossing_forbidden",
@@ -3374,7 +3447,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3382,6 +3455,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,
+        maxAttempts
+      );
+      if (!routeCrossesBoxes(rerouted, allObstacles)) {
+        return {
+          points: finalizeRoute(
+            rerouted,
+            softObstacles,
+            hardObstacles,
+            diagnostics
+          ),
+          diagnostics
+        };
+      }
+    }
+    bestPoints = greedyRerouteAroundObstacles(
+      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      allObstacles,
+      maxAttempts
+    );
+  }
   diagnostics.push({
     severity: "warning",
     code: "routing.obstacle.unavoidable",
@@ -3389,7 +3489,7 @@ function routeEdge(input) {
   });
   return {
     points: finalizeRoute(
-      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      bestPoints,
       softObstacles,
       hardObstacles,
       diagnostics
@@ -3547,6 +3647,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(
@@ -4133,7 +4297,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,
@@ -4148,7 +4314,9 @@ function solveDiagram(diagram, options = {}) {
       ...baseTextAnnotations.map((annotation) => annotation.box),
       ...frameTextAnnotation.map((annotation) => annotation.box)
     ],
-    options.textMeasurer
+    options.textMeasurer,
+    options.labelPlacement,
+    options.labelOffset
   );
   const textAnnotations = [
     ...baseTextAnnotations,
@@ -6086,7 +6254,8 @@ function coordinateBaseTextAnnotations(input) {
   }
   return annotations;
 }
-function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer) {
+function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer, labelPlacement, labelOffset3) {
+  const labelBaseOffset = labelPlacement === "beside" ? labelOffset3 ?? 16 : 10;
   const measurer = textMeasurer ?? createDefaultTextMeasurer();
   const annotations = [];
   const placedLabelBoxes = [];
@@ -6113,7 +6282,8 @@ function coordinateEdgeTextAnnotations(edges, obstacleBoxes, textMeasurer) {
       layout2,
       edges,
       obstacleBoxes,
-      placedLabelBoxes
+      placedLabelBoxes,
+      labelBaseOffset
     );
     placedLabelBoxes.push({
       x: center.x - layout2.box.width / 2,
@@ -6397,8 +6567,8 @@ function fallbackLabelLayout(text) {
     diagnostics: []
   };
 }
-function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes) {
-  const placement = labelPlacementOnPolyline2(edge.points);
+function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes, baseOffset = 10) {
+  const placement = labelPlacementOnPolyline2(edge.points, baseOffset);
   if (placement === void 0) {
     return { x: 0, y: 0 };
   }
@@ -6453,9 +6623,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) {
@@ -6465,14 +6633,90 @@ 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;
 }
-function labelPlacementOnPolyline2(points) {
-  return labelSegmentOnPolyline(points)?.placement;
+function labelPlacementOnPolyline2(points, baseOffset = 10) {
+  return labelSegmentOnPolyline(points, baseOffset)?.placement;
 }
-function labelSegmentOnPolyline(points) {
+function labelSegmentOnPolyline(points, baseOffset = 10) {
   const segments = nonZeroSegments2(points);
   const totalLength = segments.reduce(
     (sum, segment) => sum + segment.length,
@@ -6487,7 +6731,7 @@ function labelSegmentOnPolyline(points) {
       const ratio = remaining / segment.length;
       const x = segment.start.x + (segment.end.x - segment.start.x) * ratio;
       const y = segment.start.y + (segment.end.y - segment.start.y) * ratio;
-      const offset2 = labelOffset2(segment);
+      const offset2 = labelOffset2(segment, baseOffset);
       return {
         start: segment.start,
         end: segment.end,
@@ -6522,8 +6766,36 @@ function nonZeroSegments2(points) {
   }
   return segments;
 }
-function labelOffset2(segment) {
-  const offset = 10;
+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, baseOffset = 10) {
+  const offset = baseOffset;
   const dx = segment.end.x - segment.start.x;
   const dy = segment.end.y - segment.start.y;
   return {
@@ -6635,7 +6907,7 @@ function isValidEdgeId(value) {
   return value.length > 0 && EDGE_ID_PATTERN.test(value);
 }
 var directionSchema = z.enum(["TB", "LR", "BT", "RL"]);
-var routeKindSchema = z.enum(["orthogonal", "straight"]);
+var routeKindSchema = z.enum(["orthogonal", "straight", "obstacle-avoiding"]);
 var outputFormatSchema = z.enum(["svg", "excalidraw"]);
 var edgeStrokeStyleSchema = z.enum(["solid", "dashed"]);
 var edgeArrowheadSchema = z.enum(["triangle", "hollowTriangle"]);
@@ -7234,7 +7506,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 }
   });