@tscircuit/capacity-autorouter 0.0.15 → 0.0.17

package/dist/index.d.ts

@@ -92,6 +92,7 @@ declare class BaseSolver {
     iterations: number;
     progress: number;
     error: string | null;
+    failedSubSolvers?: BaseSolver[];
     /** DO NOT OVERRIDE! Override _step() instead */
     step(): void;
     _step(): void;
@@ -473,7 +474,7 @@ declare class SingleHighDensityRouteSolver extends BaseSolver {
     handleSimpleCases(): void;
     get viaPenaltyDistance(): number;
     isNodeTooCloseToObstacle(node: Node, margin?: number, isVia?: boolean): boolean;
-    isNodeTooCloseToEdge(node: Node): boolean;
+    isNodeTooCloseToEdge(node: Node, isVia?: boolean): boolean;
     doesPathToParentIntersectObstacle(node: Node): boolean;
     computeH(node: Node): number;
     computeG(node: Node): number;
@@ -504,11 +505,12 @@ declare class IntraNodeRouteSolver extends BaseSolver {
     }[];
     totalConnections: number;
     solvedRoutes: HighDensityIntraNodeRoute[];
-    failedSolvers: SingleHighDensityRouteSolver[];
+    failedSubSolvers: SingleHighDensityRouteSolver[];
     hyperParameters: Partial<HighDensityHyperParameters>;
     minDistBetweenEnteringPoints: number;
     activeSolver: SingleHighDensityRouteSolver | null;
     connMap?: ConnectivityMap;
+    get failedSolvers(): SingleHighDensityRouteSolver[];
     constructor(params: {
         nodeWithPortPoints: NodeWithPortPoints;
         colorMap?: Record<string, string>;

package/dist/index.js

@@ -43,6 +43,7 @@ var BaseSolver = class {
   iterations = 0;
   progress = 0;
   error = null;
+  failedSubSolvers;
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -1809,9 +1810,15 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     }
     return false;
   }
-  isNodeTooCloseToEdge(node) {
-    const viaRadius = this.viaDiameter / 2;
-    return node.x < this.bounds.minX + viaRadius || node.x > this.bounds.maxX - viaRadius || node.y < this.bounds.minY + viaRadius || node.y > this.bounds.maxY - viaRadius;
+  isNodeTooCloseToEdge(node, isVia) {
+    const margin = isVia ? this.viaDiameter / 2 : this.obstacleMargin;
+    const tooClose = node.x < this.bounds.minX + margin || node.x > this.bounds.maxX - margin || node.y < this.bounds.minY + margin || node.y > this.bounds.maxY - margin;
+    if (tooClose && !isVia) {
+      if (distance(node, this.B) < margin * 2) {
+        return false;
+      }
+    }
+    return tooClose;
   }
   doesPathToParentIntersectObstacle(node) {
     const parent = node.parent;
@@ -1865,6 +1872,10 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
           this.exploredNodes.add(neighborKey);
           continue;
         }
+        if (this.isNodeTooCloseToEdge(neighbor, false)) {
+          this.exploredNodes.add(neighborKey);
+          continue;
+        }
         if (this.doesPathToParentIntersectObstacle(neighbor)) {
           this.debug_nodePathToParentIntersectsObstacle.add(neighborKey);
           this.exploredNodes.add(neighborKey);
@@ -1883,9 +1894,9 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     };
     if (!this.exploredNodes.has(this.getNodeKey(viaNeighbor)) && !this.isNodeTooCloseToObstacle(
       viaNeighbor,
-      this.viaDiameter / 2 + this.obstacleMargin,
+      this.viaDiameter / 2 + this.obstacleMargin / 2,
       true
-    ) && !this.isNodeTooCloseToEdge(viaNeighbor)) {
+    ) && !this.isNodeTooCloseToEdge(viaNeighbor, true)) {
       viaNeighbor.g = this.computeG(viaNeighbor);
       viaNeighbor.h = this.computeH(viaNeighbor);
       viaNeighbor.f = this.computeF(viaNeighbor.g, viaNeighbor.h);
@@ -1977,13 +1988,15 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     graphics.points.push({
       x: this.A.x,
       y: this.A.y,
-      label: "Input A",
+      label: `Input A
+z: ${this.A.z}`,
       color: "orange"
     });
     graphics.points.push({
       x: this.B.x,
       y: this.B.y,
-      label: "Input B",
+      label: `Input B
+z: ${this.B.z}`,
       color: "orange"
     });
     graphics.lines.push({
@@ -2219,11 +2232,15 @@ var IntraNodeRouteSolver = class extends BaseSolver {
   unsolvedConnections;
   totalConnections;
   solvedRoutes;
-  failedSolvers;
+  failedSubSolvers;
   hyperParameters;
   minDistBetweenEnteringPoints;
   activeSolver = null;
   connMap;
+  // Legacy compat
+  get failedSolvers() {
+    return this.failedSubSolvers;
+  }
   constructor(params) {
     const { nodeWithPortPoints, colorMap } = params;
     super();
@@ -2231,7 +2248,7 @@ var IntraNodeRouteSolver = class extends BaseSolver {
     this.colorMap = colorMap ?? {};
     this.solvedRoutes = [];
     this.hyperParameters = params.hyperParameters ?? {};
-    this.failedSolvers = [];
+    this.failedSubSolvers = [];
     this.connMap = params.connMap;
     const unsolvedConnectionsMap = /* @__PURE__ */ new Map();
     for (const { connectionName, x, y, z } of nodeWithPortPoints.portPoints) {
@@ -2292,9 +2309,9 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         this.solvedRoutes.push(this.activeSolver.solvedPath);
         this.activeSolver = null;
       } else if (this.activeSolver.failed) {
-        this.failedSolvers.push(this.activeSolver);
+        this.failedSubSolvers.push(this.activeSolver);
         this.activeSolver = null;
-        this.error = this.failedSolvers.map((s) => s.error).join("\n");
+        this.error = this.failedSubSolvers.map((s) => s.error).join("\n");
         this.failed = true;
       }
       return;
@@ -2302,7 +2319,7 @@ var IntraNodeRouteSolver = class extends BaseSolver {
     const unsolvedConnection = this.unsolvedConnections.pop();
     this.progress = this.computeProgress();
     if (!unsolvedConnection) {
-      this.solved = this.failedSolvers.length === 0;
+      this.solved = this.failedSubSolvers.length === 0;
       return;
     }
     if (unsolvedConnection.points.length === 1) {
@@ -2373,6 +2390,20 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         }
       }
     }
+    const bounds = getBoundsFromNodeWithPortPoints(this.nodeWithPortPoints);
+    const { minX, minY, maxX, maxY } = bounds;
+    graphics.lines.push({
+      points: [
+        { x: minX, y: minY },
+        { x: maxX, y: minY },
+        { x: maxX, y: maxY },
+        { x: minX, y: maxY },
+        { x: minX, y: minY }
+      ],
+      strokeColor: "rgba(255, 0, 0, 0.25)",
+      strokeDash: "4 4",
+      layer: "border"
+    });
     return graphics;
   }
 };