@tscircuit/capacity-autorouter 0.0.33 → 0.0.35

package/dist/index.d.ts

@@ -465,13 +465,6 @@ interface HighDensityHyperParameters {
     FLIP_TRACE_ALIGNMENT_DIRECTION: boolean;
 }
 
-type FutureConnection = {
-    connectionName: string;
-    points: {
-        x: number;
-        y: number;
-    }[];
-};
 type Node = {
     x: number;
     y: number;
@@ -481,6 +474,32 @@ type Node = {
     f: number;
     parent: Node | null;
 };
+declare class SingleRouteCandidatePriorityQueue {
+    private heap;
+    constructor(nodes: Node[]);
+    private getLeftChildIndex;
+    private getRightChildIndex;
+    private getParentIndex;
+    private hasLeftChild;
+    private hasRightChild;
+    private hasParent;
+    private leftChild;
+    private rightChild;
+    private parent;
+    private swap;
+    dequeue(): Node | null;
+    enqueue(item: Node): void;
+    heapifyUp(): void;
+    heapifyDown(): void;
+}
+
+type FutureConnection = {
+    connectionName: string;
+    points: {
+        x: number;
+        y: number;
+    }[];
+};
 declare class SingleHighDensityRouteSolver extends BaseSolver {
     obstacleRoutes: HighDensityIntraNodeRoute[];
     bounds: {
@@ -519,7 +538,7 @@ declare class SingleHighDensityRouteSolver extends BaseSolver {
     VIA_PENALTY_FACTOR: number;
     CELL_SIZE_FACTOR: number;
     exploredNodes: Set<string>;
-    candidates: Node[];
+    candidates: SingleRouteCandidatePriorityQueue;
     connectionName: string;
     solvedPath: HighDensityIntraNodeRoute | null;
     futureConnections: FutureConnection[];
@@ -987,6 +1006,7 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
         z: number;
     };
     constructor(opts: {
+        connectionName?: string;
         hdRoutes: HighDensityIntraNodeRoute[];
         start: {
             x: number;

package/dist/index.js

@@ -1925,6 +1925,88 @@ function distance(p1, p2) {
   return Math.sqrt(dx * dx + dy * dy);
 }
 
+// lib/data-structures/SingleRouteCandidatePriorityQueue.ts
+var SingleRouteCandidatePriorityQueue = class {
+  heap = [];
+  constructor(nodes) {
+    this.heap = [];
+    for (const node of nodes) {
+      this.enqueue(node);
+    }
+  }
+  getLeftChildIndex(parentIndex) {
+    return 2 * parentIndex + 1;
+  }
+  getRightChildIndex(parentIndex) {
+    return 2 * parentIndex + 2;
+  }
+  getParentIndex(childIndex) {
+    return Math.floor((childIndex - 1) / 2);
+  }
+  hasLeftChild(index) {
+    return this.getLeftChildIndex(index) < this.heap.length;
+  }
+  hasRightChild(index) {
+    return this.getRightChildIndex(index) < this.heap.length;
+  }
+  hasParent(index) {
+    return this.getParentIndex(index) >= 0;
+  }
+  leftChild(index) {
+    return this.heap[this.getLeftChildIndex(index)];
+  }
+  rightChild(index) {
+    return this.heap[this.getRightChildIndex(index)];
+  }
+  parent(index) {
+    return this.heap[this.getParentIndex(index)];
+  }
+  swap(i, j) {
+    const temp = this.heap[i];
+    this.heap[i] = this.heap[j];
+    this.heap[j] = temp;
+  }
+  // Removing an element will remove the
+  // top element with highest priority then
+  // heapifyDown will be called
+  dequeue() {
+    if (this.heap.length === 0) {
+      return null;
+    }
+    const item = this.heap[0];
+    this.heap[0] = this.heap[this.heap.length - 1];
+    this.heap.pop();
+    this.heapifyDown();
+    return item;
+  }
+  enqueue(item) {
+    this.heap.push(item);
+    this.heapifyUp();
+  }
+  heapifyUp() {
+    let index = this.heap.length - 1;
+    while (this.hasParent(index) && this.parent(index).f > this.heap[index].f) {
+      this.swap(this.getParentIndex(index), index);
+      index = this.getParentIndex(index);
+    }
+  }
+  heapifyDown() {
+    let index = 0;
+    while (this.hasLeftChild(index)) {
+      let smallerChildIndex = this.getLeftChildIndex(index);
+      if (this.hasRightChild(index) && this.rightChild(index).f < this.leftChild(index).f) {
+        smallerChildIndex = this.getRightChildIndex(index);
+      }
+      if (this.heap[index].f < this.heap[smallerChildIndex].f) {
+        break;
+      } else {
+        this.swap(index, smallerChildIndex);
+      }
+      index = smallerChildIndex;
+    }
+  }
+};
+
 // lib/solvers/HighDensitySolver/SingleHighDensityRouteSolver.ts
 var SingleHighDensityRouteSolver = class extends BaseSolver {
   obstacleRoutes;
@@ -1979,7 +2061,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     this.obstacleMargin = opts.obstacleMargin ?? 0.2;
     this.layerCount = opts.layerCount ?? 2;
     this.exploredNodes = /* @__PURE__ */ new Set();
-    this.candidates = [
+    this.candidates = new SingleRouteCandidatePriorityQueue([
       {
         ...opts.A,
         z: opts.A.z ?? 0,
@@ -1988,7 +2070,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
         f: 0,
         parent: null
       }
-    ];
+    ]);
     this.straightLineDistance = distance(this.A, this.B);
     this.futureConnections = opts.futureConnections ?? [];
     this.MAX_ITERATIONS = 5e3;
@@ -2208,17 +2290,18 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     );
   }
   _step() {
-    this.candidates.sort((a, b) => b.f - a.f);
-    let currentNode = this.candidates.pop();
-    while (currentNode && this.exploredNodes.has(this.getNodeKey(currentNode))) {
-      currentNode = this.candidates.pop();
+    let currentNode = this.candidates.dequeue();
+    let currentNodeKey = currentNode ? this.getNodeKey(currentNode) : void 0;
+    while (currentNode && currentNodeKey && this.exploredNodes.has(currentNodeKey)) {
+      currentNode = this.candidates.dequeue();
+      currentNodeKey = currentNode ? this.getNodeKey(currentNode) : void 0;
     }
-    if (!currentNode) {
+    if (!currentNode || !currentNodeKey) {
       this.failed = true;
       return;
     }
-    this.exploredNodes.add(this.getNodeKey(currentNode));
-    this.debug_exploredNodesOrdered.push(this.getNodeKey(currentNode));
+    this.exploredNodes.add(currentNodeKey);
+    this.debug_exploredNodesOrdered.push(currentNodeKey);
     const goalDist = distance(currentNode, this.B);
     this.progress = this.computeProgress(
       currentNode,
@@ -2231,7 +2314,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     }
     const neighbors = this.getNeighbors(currentNode);
     for (const neighbor of neighbors) {
-      this.candidates.push(neighbor);
+      this.candidates.enqueue(neighbor);
     }
   }
   visualize() {
@@ -4213,7 +4296,7 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
     super();
     this.remainingHdRoutes = [...opts.hdRoutes];
     this.mergedHdRoute = {
-      connectionName: opts.hdRoutes[0].connectionName,
+      connectionName: opts.connectionName ?? opts.hdRoutes[0].connectionName,
       route: [
         {
           x: opts.start.x,
@@ -4222,8 +4305,8 @@ var SingleHighDensityRouteStitchSolver = class extends BaseSolver {
         }
       ],
       vias: [],
-      viaDiameter: opts.hdRoutes[0].viaDiameter,
-      traceThickness: opts.hdRoutes[0].traceThickness
+      viaDiameter: opts.hdRoutes?.[0]?.viaDiameter ?? 0.6,
+      traceThickness: opts.hdRoutes?.[0]?.traceThickness ?? 0.15
     };
     this.start = opts.start;
     this.end = opts.end;
@@ -4382,11 +4465,8 @@ var MultipleHighDensityRouteStitchSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    if (unsolvedRoute.hdRoutes.length === 0) {
-      console.warn(`No routes to stitch for ${unsolvedRoute.connectionName}`);
-      return;
-    }
     this.activeSolver = new SingleHighDensityRouteStitchSolver({
+      connectionName: unsolvedRoute.connectionName,
       hdRoutes: unsolvedRoute.hdRoutes,
       start: unsolvedRoute.start,
       end: unsolvedRoute.end