@crazyhappyone/auto-graph 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -2071,7 +2071,7 @@ function point(value) {
   return { x: value.x, y: value.y };
 }
 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"]);
@@ -3750,6 +3750,15 @@ function indent(value) {
 function indentLines(values) {
   return values.map(indent);
 }
+
+// src/ir/diagnostics.ts
+var DELIVERABILITY_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  "constraints.locked-target-not-moved",
+  "routing.evidence.crossing_forbidden",
+  "routing.obstacle.unavoidable",
+  "route_obstacle_fallback",
+  "routing.text-clearance.unresolved"
+]);
 var DEFAULT_OPTIONS = {
   nodesep: 80,
   ranksep: 100,
@@ -3948,6 +3957,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",
@@ -3955,7 +4009,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        hardClearCandidate.points,
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3964,6 +4018,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",
@@ -3971,7 +4052,7 @@ function routeEdge(input) {
     });
     return {
       points: finalizeRoute(
-        candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+        bestPoints2,
         softObstacles,
         hardObstacles,
         diagnostics
@@ -3979,6 +4060,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",
@@ -3986,7 +4094,7 @@ function routeEdge(input) {
   });
   return {
     points: finalizeRoute(
-      candidateRoutes[0]?.points ?? fallbackRoute(input, defaultAnchors),
+      bestPoints,
       softObstacles,
       hardObstacles,
       diagnostics
@@ -3996,21 +4104,29 @@ function routeEdge(input) {
 }
 function finalizeRoute(points, softObstacles, hardObstacles, diagnostics) {
   const simplified = simplifyRoute(points);
+  if (simplified.length >= 3) {
+    return simplified;
+  }
   const crossesHardObstacles = routeCrossesBoxes(simplified, hardObstacles);
   const crossesSoftObstacles = routeCrossesBoxes(simplified, softObstacles);
-  if (simplified.length < 3 && (crossesHardObstacles || crossesSoftObstacles)) {
+  if (!crossesHardObstacles && !crossesSoftObstacles) {
+    return simplified;
+  }
+  const expanded = expandFallbackRoute(simplified, [
+    ...softObstacles,
+    ...hardObstacles
+  ]);
+  const expandedCrossesHard = routeCrossesBoxes(expanded, hardObstacles);
+  const expandedCrossesSoft = routeCrossesBoxes(expanded, softObstacles);
+  if (expandedCrossesHard || expandedCrossesSoft) {
     diagnostics.push({
-      severity: crossesHardObstacles ? "error" : "warning",
+      severity: expandedCrossesHard ? "error" : "warning",
       code: "route_obstacle_fallback",
       message: "Obstacle-aware routing fell back to fewer than three route points.",
       detail: { pointCount: simplified.length }
     });
-    return expandFallbackRoute(simplified, [
-      ...softObstacles,
-      ...hardObstacles
-    ]);
   }
-  return simplified;
+  return expanded;
 }
 function expandFallbackRoute(points, obstacles) {
   if (points.length !== 2) {
@@ -4041,12 +4157,12 @@ function expandFallbackRoute(points, obstacles) {
   const hv = diagonalDetourHV(source, target, obstacles);
   const vh = diagonalDetourVH(source, target, obstacles);
   const viable = [hv, vh].filter((c) => !routeCrossesBoxes(c, obstacles));
-  if (viable.length > 0) {
+  const [firstViable, ...remainingViable] = viable;
+  if (firstViable !== void 0) {
     const directLen = Math.hypot(target.x - source.x, target.y - source.y);
-    let best = viable[0];
-    for (let i = 1; i < viable.length; i += 1) {
-      const cand = viable[i];
-      if (cand !== void 0 && pathLength(cand) - directLen < pathLength(best) - directLen) {
+    let best = firstViable;
+    for (const cand of remainingViable) {
+      if (pathLength(cand) - directLen < pathLength(best) - directLen) {
         best = cand;
       }
     }
@@ -4136,6 +4252,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(
@@ -4632,6 +4812,7 @@ function solveDiagram(diagram, options = {}) {
   ];
   const initialContentBounds = layoutBoxes.length === 0 ? { x: 0, y: 0, width: 0} : unionBoxes(layoutBoxes);
   placeEvidenceBlocks(
+    options.obstacleMargin ?? 0,
     [
       ...coordinatedMatrices,
       ...coordinatedTables,
@@ -4698,17 +4879,35 @@ function solveDiagram(diagram, options = {}) {
     ...baseTextAnnotations.filter(isPreRouteTextObstacle),
     ...frameTextAnnotation.filter(isPreRouteTextObstacle)
   ];
+  const margin = options.obstacleMargin ?? 0;
+  const softObstacles = [
+    ...coordinatedTables.map((table) => expandBox(table.box, margin)),
+    ...coordinatedEvidencePanels.map((panel) => expandBox(panel.box, margin))
+  ];
+  const hardObstacles = coordinatedMatrices.map(
+    (matrix) => expandBox(matrix.box, margin)
+  );
+  const titleBarObstacles = [];
+  if (frame !== void 0) {
+    titleBarObstacles.push(expandBox(frame.titleBox, margin));
+  }
+  for (const swimlane of coordinatedSwimlanes) {
+    for (const lane of swimlane.lanes) {
+      if (lane.headerBox !== void 0 && lane.headerBox.width > 0 && lane.headerBox.height > 0) {
+        titleBarObstacles.push(expandBox(lane.headerBox, margin));
+      }
+    }
+  }
   const coordinatedEdges = coordinateEdges(
     styledEdges,
     nodeGeometryById,
     coordinatedNodes,
-    [...nodeGeometryById.values()].map((geometry) => geometry.obstacleBox),
-    [
-      ...coordinatedTables.map((table) => table.box),
-      ...coordinatedEvidencePanels.map((panel) => panel.box)
-    ],
+    [...nodeGeometryById.values()].map(
+      (geometry) => options.routingGutter === void 0 ? geometry.obstacleBox : expandBox(geometry.obstacleBox, options.routingGutter)
+    ),
+    [...softObstacles, ...titleBarObstacles],
     routingTextObstacles,
-    coordinatedMatrices.map((matrix) => matrix.box),
+    hardObstacles,
     diagram.direction,
     options,
     diagnostics
@@ -4743,6 +4942,16 @@ function solveDiagram(diagram, options = {}) {
       options.pageBounds
     )
   );
+  let degraded = false;
+  const resultDiagnostics = diagnostics.map((diagnostic) => {
+    if (DELIVERABILITY_DIAGNOSTIC_CODES.has(diagnostic.code)) {
+      degraded = true;
+      if (options.strict) {
+        return { ...diagnostic, severity: "error" };
+      }
+    }
+    return diagnostic;
+  });
   return {
     id: diagram.id,
     ...diagram.title === void 0 ? {} : { title: diagram.title },
@@ -4754,7 +4963,8 @@ function solveDiagram(diagram, options = {}) {
     ...coordinatedMatrices.length === 0 ? {} : { matrices: coordinatedMatrices },
     ...coordinatedTables.length === 0 ? {} : { tables: coordinatedTables },
     ...coordinatedEvidencePanels.length === 0 ? {} : { evidencePanels: coordinatedEvidencePanels },
-    diagnostics,
+    diagnostics: resultDiagnostics,
+    degraded,
     bounds: frame === void 0 ? unionBoxes(boundsBase) : unionBoxes([...boundsBase, frame.box, frame.titleBox]),
     ...frame === void 0 ? {} : { frame },
     ...textAnnotations.length === 0 ? {} : { textAnnotations },
@@ -6143,16 +6353,25 @@ function blockBox(block, defaultSize) {
     height: block.size?.height ?? defaultSize.height
   };
 }
-function placeEvidenceBlocks(blocks, contentBounds) {
+function placeEvidenceBlocks(obstacleMargin, blocks, contentBounds) {
+  const margin = normalizeInsets(obstacleMargin);
+  const horizontalGap = Math.max(
+    DEFAULT_EVIDENCE_BLOCK_GAP,
+    margin.right + margin.left
+  );
+  const verticalGap = Math.max(
+    DEFAULT_EVIDENCE_BLOCK_GAP,
+    margin.bottom + margin.top
+  );
   let nextY = contentBounds.y;
-  const x = contentBounds.x + contentBounds.width + DEFAULT_EVIDENCE_BLOCK_GAP;
+  const x = contentBounds.x + contentBounds.width + horizontalGap;
   for (const block of blocks) {
     if (block.position !== void 0) {
       continue;
     }
     block.box.x = x;
     block.box.y = nextY;
-    nextY += block.box.height + DEFAULT_EVIDENCE_BLOCK_GAP;
+    nextY += block.box.height + verticalGap;
   }
 }
 function columnXOffsets(table, box) {
@@ -7008,9 +7227,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) {
@@ -7020,7 +7237,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;
 }
@@ -7077,6 +7370,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;
@@ -7191,7 +7512,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 }
   });
@@ -7383,6 +7704,7 @@ function isPointLikeRecord(value) {
 
 exports.DEFAULT_CANONICAL_PRECISION = DEFAULT_CANONICAL_PRECISION;
 exports.DEFAULT_DSL_MAX_BYTES = DEFAULT_DSL_MAX_BYTES;
+exports.DELIVERABILITY_DIAGNOSTIC_CODES = DELIVERABILITY_DIAGNOSTIC_CODES;
 exports.DeterministicTextMeasurer = DeterministicTextMeasurer;
 exports.LabelFitter = LabelFitter;
 exports.PretextTextMeasurer = PretextTextMeasurer;