@crazyhappyone/auto-graph 0.2.9 → 0.2.11

package/dist/index.d.cts

@@ -770,6 +770,12 @@ interface RouteEdgeInput {
     hardObstacleIndex?: BoxSpatialIndex;
     /** Maximum greedy rerouting iterations (default 5). */
     maxRoutingAttempts?: number;
+    /** Corridor expansion margin in px for corner-graph prefilter (default 32).
+     * Larger values include more obstacles in the local routing window. */
+    corridorMargin?: number;
+    /** Route-length / direct-distance ratio above which a backtracking
+     * warning is emitted (default 20). */
+    maxBacktrackingRatio?: number;
 }
 interface RouteEdgeResult {
     points: Point[];
@@ -832,6 +838,15 @@ interface SolveDiagramOptions {
     labelPlacement?: "beside" | "on-path";
     /** Pixels to offset edge labels from the edge path when labelPlacement is "beside". */
     labelOffset?: number;
+    /** Corridor expansion margin for corner-graph prefilter.
+     * - number: fixed px margin
+     * - "auto" (default): max(200, contentDiagonal * 0.3)
+     * Larger margins include more obstacles in the local routing window,
+     * improving path quality on dense diagrams at the cost of more vertices. */
+    corridorMargin?: number | "auto";
+    /** Route-length / direct-distance ratio above which a backtracking
+     * warning is emitted (default 20). */
+    maxBacktrackingRatio?: number;
 }
 interface PortShiftingOptions {
     enabled?: boolean;

package/dist/index.d.ts

@@ -770,6 +770,12 @@ interface RouteEdgeInput {
     hardObstacleIndex?: BoxSpatialIndex;
     /** Maximum greedy rerouting iterations (default 5). */
     maxRoutingAttempts?: number;
+    /** Corridor expansion margin in px for corner-graph prefilter (default 32).
+     * Larger values include more obstacles in the local routing window. */
+    corridorMargin?: number;
+    /** Route-length / direct-distance ratio above which a backtracking
+     * warning is emitted (default 20). */
+    maxBacktrackingRatio?: number;
 }
 interface RouteEdgeResult {
     points: Point[];
@@ -832,6 +838,15 @@ interface SolveDiagramOptions {
     labelPlacement?: "beside" | "on-path";
     /** Pixels to offset edge labels from the edge path when labelPlacement is "beside". */
     labelOffset?: number;
+    /** Corridor expansion margin for corner-graph prefilter.
+     * - number: fixed px margin
+     * - "auto" (default): max(200, contentDiagonal * 0.3)
+     * Larger margins include more obstacles in the local routing window,
+     * improving path quality on dense diagrams at the cost of more vertices. */
+    corridorMargin?: number | "auto";
+    /** Route-length / direct-distance ratio above which a backtracking
+     * warning is emitted (default 20). */
+    maxBacktrackingRatio?: number;
 }
 interface PortShiftingOptions {
     enabled?: boolean;

package/dist/index.js

@@ -5381,7 +5381,7 @@ function segmentCrossesAnyObstacle(a, b, obstacles) {
 }
 
 // src/routing/routes.ts
-function checkBacktracking(points, source, target, diagnostics) {
+function checkBacktracking(points, source, target, diagnostics, maxRatio) {
   if (points.length < 2) return;
   const direct = Math.hypot(target.x - source.x, target.y - source.y);
   if (direct <= 0) return;
@@ -5391,7 +5391,7 @@ function checkBacktracking(points, source, target, diagnostics) {
     const b = points[i + 1];
     routeLen += Math.hypot(b.x - a.x, b.y - a.y);
   }
-  const threshold = 10;
+  const threshold = maxRatio ?? 20;
   if (routeLen > direct * threshold) {
     diagnostics.push({
       severity: "warning",
@@ -5409,8 +5409,20 @@ function routeEdge(input) {
   const diagnostics = [];
   const softObstacles = input.obstacles ?? [];
   const hardObstacles = input.hardObstacles ?? [];
+  let bestRejectedPath;
+  let bestRejectedCrossings = Number.POSITIVE_INFINITY;
   const softObstacleIndex = input.obstacleIndex ?? createBoxSpatialIndex(indexedBoxes(softObstacles));
   const hardObstacleIndex = input.hardObstacleIndex ?? createBoxSpatialIndex(indexedBoxes(hardObstacles));
+  const recordRejected = (candidate) => {
+    if (routeIntersectsObstacles(candidate, hardObstacles, hardObstacleIndex)) {
+      return;
+    }
+    const crossings = countObstacleCrossings(candidate, softObstacles);
+    if (crossings < bestRejectedCrossings) {
+      bestRejectedCrossings = crossings;
+      bestRejectedPath = candidate;
+    }
+  };
   const maxAttempts = input.maxRoutingAttempts ?? 5;
   const defaultAnchors = defaultAnchorsForGeometry(
     input.source.box,
@@ -5470,13 +5482,14 @@ function routeEdge(input) {
         targetAnchor
       );
       const allObstacles = [...softObstacles, ...hardObstacles];
+      const corridorMargin = input.corridorMargin ?? 32;
       const corridorObstacles = filterObstaclesByCorridor(
         source,
         target,
         allObstacles,
         [],
         // endpointObstacles passed separately via options
-        32
+        corridorMargin
       );
       const cornerObstacles = corridorObstacles.length === 0 && allObstacles.length > 0 ? allObstacles : corridorObstacles;
       let cornerPath = findCornerGraphPath(
@@ -5499,7 +5512,7 @@ function routeEdge(input) {
         source,
         target,
         allObstacles,
-        { endpointObstacles, margin: 0 },
+        { endpointObstacles, margin: 0, corridorMargin },
         diagnostics
       );
       if (path !== null && path.length >= 2) {
@@ -5516,9 +5529,16 @@ function routeEdge(input) {
           softObstacles,
           softObstacleIndex
         ) && !routeIntersectsObstacles(finalized, hardObstacles, hardObstacleIndex)) {
-          checkBacktracking(finalized, source, target, diagnostics);
+          checkBacktracking(
+            finalized,
+            source,
+            target,
+            diagnostics,
+            input.maxBacktrackingRatio
+          );
           return { points: finalized, diagnostics };
         }
+        recordRejected(finalized);
         if (cornerPath !== null) {
           const fullCornerPath = cornerObstacles.length < allObstacles.length ? findCornerGraphPath(
             source,
@@ -5545,15 +5565,22 @@ function routeEdge(input) {
               hardObstacles,
               hardObstacleIndex
             )) {
-              checkBacktracking(fullFinalized, source, target, diagnostics);
+              checkBacktracking(
+                fullFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
               return { points: fullFinalized, diagnostics };
             }
+            recordRejected(fullFinalized);
           }
           const gridPath = findObstacleFreePath(
             source,
             target,
             allObstacles,
-            { endpointObstacles, margin: 0 },
+            { endpointObstacles, margin: 0, corridorMargin },
             diagnostics
           );
           if (gridPath !== null && gridPath.length >= 2) {
@@ -5574,9 +5601,16 @@ function routeEdge(input) {
               hardObstacles,
               hardObstacleIndex
             )) {
-              checkBacktracking(gridFinalized, source, target, diagnostics);
+              checkBacktracking(
+                gridFinalized,
+                source,
+                target,
+                diagnostics,
+                input.maxBacktrackingRatio
+              );
               return { points: gridFinalized, diagnostics };
             }
+            recordRejected(gridFinalized);
           }
         }
       }
@@ -5640,7 +5674,8 @@ function routeEdge(input) {
         finalizedClean,
         candidate.points[0],
         candidate.points[candidate.points.length - 1],
-        diagnostics
+        diagnostics,
+        input.maxBacktrackingRatio
       );
       return { points: finalizedClean, diagnostics };
     }
@@ -5706,13 +5741,41 @@ function routeEdge(input) {
       code: "routing.obstacle.unavoidable",
       message: "No bounded orthogonal route candidate avoided all soft obstacles."
     });
-    return {
-      points: finalizeRoute(
-        bestPoints2,
+    const finalizedSoftBest = finalizeRoute(
+      bestPoints2,
+      softObstacles,
+      hardObstacles,
+      diagnostics
+    );
+    let softFallback = finalizedSoftBest;
+    if (bestRejectedPath !== void 0) {
+      const finalizedRejected = finalizeRoute(
+        bestRejectedPath,
         softObstacles,
         hardObstacles,
         diagnostics
-      ),
+      );
+      const rejectedCrossings = countObstacleCrossings(
+        finalizedRejected,
+        softObstacles
+      );
+      const heuristicCrossings = countObstacleCrossings(
+        finalizedSoftBest,
+        softObstacles
+      );
+      if (rejectedCrossings < heuristicCrossings) {
+        softFallback = finalizedRejected;
+      }
+    }
+    checkBacktracking(
+      softFallback,
+      softFallback[0],
+      softFallback[softFallback.length - 1],
+      diagnostics,
+      input.maxBacktrackingRatio
+    );
+    return {
+      points: softFallback,
       diagnostics
     };
   }
@@ -5744,6 +5807,22 @@ function routeEdge(input) {
         maxAttempts
       );
     }
+    if (bestRejectedPath !== void 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "routing.obstacle.unavoidable",
+        message: "Using A* route with minor soft-obstacle crossings to avoid hard evidence obstacles."
+      });
+      return {
+        points: finalizeRoute(
+          bestRejectedPath,
+          softObstacles,
+          hardObstacles,
+          diagnostics
+        ),
+        diagnostics
+      };
+    }
     diagnostics.push({
       severity: "error",
       code: "routing.evidence.crossing_forbidden",
@@ -5791,13 +5870,41 @@ function routeEdge(input) {
     code: "routing.obstacle.unavoidable",
     message: "No bounded orthogonal route candidate avoided all obstacles."
   });
-  return {
-    points: finalizeRoute(
-      bestPoints,
+  const finalizedBestPoints = finalizeRoute(
+    bestPoints,
+    softObstacles,
+    hardObstacles,
+    diagnostics
+  );
+  let fallbackPoints = finalizedBestPoints;
+  if (bestRejectedPath !== void 0) {
+    const finalizedRejected = finalizeRoute(
+      bestRejectedPath,
       softObstacles,
       hardObstacles,
       diagnostics
-    ),
+    );
+    const rejectedCrossings = countObstacleCrossings(
+      finalizedRejected,
+      softObstacles
+    );
+    const heuristicCrossings = countObstacleCrossings(
+      finalizedBestPoints,
+      softObstacles
+    );
+    if (rejectedCrossings < heuristicCrossings) {
+      fallbackPoints = finalizedRejected;
+    }
+  }
+  checkBacktracking(
+    fallbackPoints,
+    fallbackPoints[0],
+    fallbackPoints[fallbackPoints.length - 1],
+    diagnostics,
+    input.maxBacktrackingRatio
+  );
+  return {
+    points: fallbackPoints,
     diagnostics
   };
 }
@@ -6296,6 +6403,24 @@ function routeIntersectsObstacles(points, obstacles, spatialIndex) {
   }
   return false;
 }
+function countObstacleCrossings(points, obstacles) {
+  let count = 0;
+  for (const obstacle of obstacles) {
+    validateBox(obstacle);
+    for (let pointIndex = 0; pointIndex < points.length - 1; pointIndex += 1) {
+      const a = points[pointIndex];
+      const b = points[pointIndex + 1];
+      if (a === void 0 || b === void 0) {
+        continue;
+      }
+      if (intersectsAabb(segmentBox2(a, b), obstacle)) {
+        count += 1;
+        break;
+      }
+    }
+  }
+  return count;
+}
 function routeIntersectsEndpointInteriors(points, endpointInteriors) {
   for (let index = 0; index < points.length - 1; index += 1) {
     const a = points[index];
@@ -6741,7 +6866,8 @@ function solveDiagram(diagram, options = {}) {
     constrained.boxes,
     constrained.locks,
     options?.overlapSpacing ?? 40,
-    Math.max(0, options?.minLaneGutter ?? 0)
+    Math.max(0, options?.minLaneGutter ?? 0),
+    options.distributeContainedChildren ?? true
   );
   removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
   diagnostics.push(...swimlaneContracts.diagnostics);
@@ -6908,7 +7034,8 @@ function solveDiagram(diagram, options = {}) {
     diagram.direction,
     options,
     diagnostics,
-    coordinatedGroups
+    coordinatedGroups,
+    contentBounds
   );
   const edgeTextAnnotations = coordinateEdgeTextAnnotations(
     coordinatedEdges,
@@ -7330,7 +7457,7 @@ function reportCjkTypographyDiagnostics(path, typography, previousStyle, diagnos
 function containsCjk(value) {
   return /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u.test(value);
 }
-function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter) {
+function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottomFlow, nodeBoxes, locks, overlapSpacing, laneGutter, distributeContainedChildren) {
   const layouts = /* @__PURE__ */ new Map();
   const diagnostics = [];
   const movedChildIds = /* @__PURE__ */ new Set();
@@ -7349,7 +7476,9 @@ function applySwimlaneLayoutContracts(swimlanes, constraints, edges, topToBottom
       locks,
       diagnostics,
       movedChildIds,
-      laneGutter
+      laneGutter,
+      constraints,
+      distributeContainedChildren
     );
     if (layout2 !== void 0) {
       layouts.set(swimlane.id, layout2);
@@ -7541,7 +7670,7 @@ function isStackRunaway(boxes, nodes, direction, options) {
   const maxWidth = Math.max(...nodeBoxes.map((box) => box.width));
   return xSpread <= Math.max(maxWidth, options.overlapSpacing ?? 40);
 }
-function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter) {
+function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, locks, diagnostics, movedChildIds, laneGutter, constraints, distributeContainedChildren) {
   const headerHeight = swimlane.headerHeight ?? 28;
   const padding = swimlane.padding ?? 16;
   const laneBounds = swimlane.lanes.map((lane) => {
@@ -7566,7 +7695,9 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
       locks,
       diagnostics,
       movedChildIds,
-      laneGutter
+      laneGutter,
+      constraints,
+      distributeContainedChildren
     );
   }
   return applyHorizontalSwimlaneContract(
@@ -7581,13 +7712,29 @@ function applySingleSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes
     laneGutter
   );
 }
-function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter) {
+function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBoxes, laneBounds, headerHeight, padding, locks, diagnostics, movedChildIds, laneGutter, constraints, distributeContainedChildren) {
   const populatedBounds = laneBounds.filter(
     (box) => box !== void 0
   );
   const top = Math.min(...populatedBounds.map((box) => box.y));
   const left = Math.min(...populatedBounds.map((box) => box.x));
   const maxChildHeight = Math.max(...populatedBounds.map((box) => box.height));
+  const containedChildIds = /* @__PURE__ */ new Set();
+  if (distributeContainedChildren) {
+    for (const c of constraints) {
+      if (c.kind !== "containment") continue;
+      if (nodeBoxes.get(c.containerId) === void 0) continue;
+      const distributable = c.childIds.filter((childId) => {
+        if (nodeBoxes.get(childId) === void 0) return false;
+        const lock = locks.get(childId);
+        return lock === void 0 || lock.source === "fixed-position";
+      });
+      if (distributable.length < 2) continue;
+      for (const childId of distributable) {
+        containedChildIds.add(childId);
+      }
+    }
+  }
   const flowRanks = topToBottomFlow ? rankVerticalSwimlaneChildren(swimlane, edges) : /* @__PURE__ */ new Map();
   const maxRank = flowRanks.size === 0 ? 0 : Math.max(...Array.from(flowRanks.values()));
   const rankStackGap = Math.max(8, padding / 2);
@@ -7604,7 +7751,8 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
     nodeBoxes,
     flowRanks,
     locks,
-    rankStackGap
+    rankStackGap,
+    containedChildIds
   );
   const slotWidth = Math.max(
     Math.max(...populatedBounds.map((box) => box.width)),
@@ -7626,7 +7774,10 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       const distributable = lane.children.filter(
         (childId) => !locks.has(childId)
       );
-      if (distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
+      const coveredByContainment = lane.children.some(
+        (childId) => containedChildIds.has(childId)
+      );
+      if (!coveredByContainment && distributable.length >= CROSS_AXIS_SPREAD_THRESHOLD) {
         moveRankedVerticalLaneChildren(
           lane.children,
           nodeBoxes,
@@ -7654,6 +7805,9 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       );
       continue;
     }
+    const rankedCoveredByContainment = lane.children.some(
+      (childId) => containedChildIds.has(childId)
+    );
     moveRankedVerticalLaneChildren(
       lane.children,
       nodeBoxes,
@@ -7664,7 +7818,8 @@ function applyVerticalSwimlaneContract(swimlane, edges, topToBottomFlow, nodeBox
       rankSpacing,
       rankStackGap,
       { x: target.x, y: laneContentTop },
-      slotWidth - padding * 2
+      slotWidth - padding * 2,
+      rankedCoveredByContainment
     );
   }
   return {
@@ -7780,9 +7935,12 @@ function crossAxisSpreadWidth(items, gap) {
     0
   );
 }
-function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap) {
+function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap, containedChildIds) {
   let maxWidth = 0;
   for (const lane of swimlane.lanes) {
+    if (containedChildIds !== void 0 && lane.children.some((childId) => containedChildIds.has(childId))) {
+      continue;
+    }
     for (const stack of rankStacks(
       lane.children,
       nodeBoxes,
@@ -7795,7 +7953,7 @@ function maxCrossAxisSpreadWidth(swimlane, nodeBoxes, flowRanks, locks, gap) {
   }
   return maxWidth;
 }
-function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth) {
+function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics, movedChildIds, flowRanks, rankSpacing, rankStackGap, target, contentWidth, suppressSpread) {
   for (const [rank, stack] of rankStacks(childIds, nodeBoxes, flowRanks)) {
     const unlocked = [];
     for (const item of stack) {
@@ -7824,7 +7982,7 @@ function moveRankedVerticalLaneChildren(childIds, nodeBoxes, locks, diagnostics,
       }
       nodeBoxes.set(childId, next);
     } else {
-      const shouldSpread = unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
+      const shouldSpread = !suppressSpread && unlocked.length >= CROSS_AXIS_SPREAD_THRESHOLD;
       if (!shouldSpread) {
         let yOffset = 0;
         for (const { childId, box } of unlocked) {
@@ -8953,14 +9111,21 @@ function evidenceOverlapDiagnostic(block, conflict) {
     }
   };
 }
-function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics, groups) {
+function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacles, textObstacles, hardObstacles, direction, options, diagnostics, groups, contentBounds) {
   const coordinated = [];
   const coordinatedNodeById = new Map(
     coordinatedNodes.map((node) => [node.id, node])
   );
+  const corridorMarginOption = options.corridorMargin ?? "auto";
+  const corridorMargin = typeof corridorMarginOption === "number" ? corridorMarginOption : Math.max(
+    200,
+    Math.hypot(contentBounds.width, contentBounds.height) * 0.3
+  );
+  const routingGutter = options.routingGutter ?? 160;
+  const queryGutter = (options.routeKind ?? "orthogonal") === "obstacle-avoiding" ? Math.max(routingGutter, corridorMargin) : routingGutter;
   const nodeObstacleIndex = createBoxSpatialIndex(
     obstacles.map((box, index) => ({ id: `node-obstacle:${index}`, box })),
-    options.routingGutter ?? 160
+    queryGutter
   );
   for (const edge of edges) {
     const source = nodes.get(edge.source.nodeId);
@@ -8982,11 +9147,7 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
     const sourcePort = coordinatedNodeById.get(edge.source.nodeId)?.ports?.find((port) => port.id === edge.source.portId);
     const targetPort = coordinatedNodeById.get(edge.target.nodeId)?.ports?.find((port) => port.id === edge.target.portId);
     const routeTextObstacles = textObstacles.filter((annotation) => !isEdgeConnectedTextAnnotation(edge, annotation)).map((annotation) => annotation.box);
-    const corridor = edgeCorridorBox(
-      source.box,
-      target.box,
-      options.routingGutter ?? 160
-    );
+    const corridor = edgeCorridorBox(source.box, target.box, queryGutter);
     const routeNodeObstacles = queryBoxSpatialIndex(nodeObstacleIndex, corridor).map((entry) => entry.box).filter(
       (obstacle) => !sameBox(obstacle, source.obstacleBox) && !sameBox(obstacle, target.obstacleBox)
     );
@@ -9004,7 +9165,9 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
         ...routeTextObstacles
       ],
       hardObstacles,
-      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts }
+      corridorMargin,
+      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts },
+      ...options.maxBacktrackingRatio === void 0 ? {} : { maxBacktrackingRatio: options.maxBacktrackingRatio }
     });
     diagnostics.push(
       ...route.diagnostics.map((diagnostic) => ({