@tscircuit/capacity-autorouter 0.0.34 → 0.0.36

package/dist/index.d.ts

@@ -105,6 +105,11 @@ declare class BaseSolver {
     _step(): void;
     solve(): void;
     visualize(): GraphicsObject;
+    /**
+     * A lightweight version of the visualize method that can be used to stream
+     * progress
+     */
+    preview(): GraphicsObject;
 }
 
 declare class CapacityMeshEdgeSolver extends BaseSolver {
@@ -465,13 +470,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 +479,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 +543,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[];
@@ -1428,6 +1452,16 @@ declare class CapacityMeshSolver extends BaseSolver {
     _step(): void;
     getCurrentPhase(): string;
     visualize(): GraphicsObject;
+    /**
+     * A lightweight version of the visualize method that can be used to stream
+     * progress
+     *
+     * We return the most relevant graphic for the stage:
+     * 1. netToPointPairs output
+     * 2. Capacity Planning Output
+     * 3. High Density Route Solver Output, max 200 lines
+     */
+    preview(): GraphicsObject;
     /**
      * Get original connection name from connection name with MST suffix
      * @param mstConnectionName The MST-suffixed connection name (e.g. "connection1_mst0")

package/dist/index.js

@@ -83,6 +83,18 @@ var BaseSolver = class {
       circles: []
     };
   }
+  /**
+   * A lightweight version of the visualize method that can be used to stream
+   * progress
+   */
+  preview() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+  }
 };
 
 // node_modules/@babel/runtime/helpers/esm/extends.js
@@ -1925,6 +1937,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 +2073,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 +2082,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 +2302,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 +2326,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() {
@@ -8003,6 +8098,50 @@ var CapacityMeshSolver = class extends BaseSolver {
     ].filter(Boolean);
     return combineVisualizations(...visualizations);
   }
+  /**
+   * A lightweight version of the visualize method that can be used to stream
+   * progress
+   *
+   * We return the most relevant graphic for the stage:
+   * 1. netToPointPairs output
+   * 2. Capacity Planning Output
+   * 3. High Density Route Solver Output, max 200 lines
+   */
+  preview() {
+    if (this.highDensityRouteSolver) {
+      const lines = [];
+      for (let i = this.highDensityRouteSolver.routes.length - 1; i >= 0; i--) {
+        const route = this.highDensityRouteSolver.routes[i];
+        lines.push({
+          points: route.route.map((n) => ({
+            x: n.x,
+            y: n.y
+          })),
+          strokeColor: this.colorMap[route.connectionName]
+        });
+        if (lines.length > 200) break;
+      }
+      return { lines };
+    }
+    if (this.pathingSolver) {
+      const lines = [];
+      for (const connection of this.pathingSolver.connectionsWithNodes) {
+        if (!connection.path) continue;
+        lines.push({
+          points: connection.path.map((n) => ({
+            x: n.center.x,
+            y: n.center.y
+          })),
+          strokeColor: this.colorMap[connection.connection.name]
+        });
+      }
+      return { lines };
+    }
+    if (this.netToPointPairsSolver) {
+      return this.netToPointPairsSolver?.visualize();
+    }
+    return {};
+  }
   /**
    * Get original connection name from connection name with MST suffix
    * @param mstConnectionName The MST-suffixed connection name (e.g. "connection1_mst0")