@tscircuit/core 0.0.134 → 0.0.135

package/dist/index.d.ts

@@ -106,6 +106,10 @@ declare class Circuit {
  */
 declare const Project: typeof Circuit;
 
+interface ISubcircuit extends PrimitiveComponent {
+    _shouldUseTraceByTraceRouting(): boolean;
+}
+
 interface BaseComponentConfig {
     componentName: string;
     schematicSymbolName?: BaseSymbolName | null;
@@ -256,7 +260,7 @@ declare abstract class PrimitiveComponent<ZodProps extends ZodType = any> extend
         height: number;
     };
     doesSelectorMatch(selector: string): boolean;
-    getSubcircuit(): PrimitiveComponent;
+    getSubcircuit(): ISubcircuit;
     selectAll(selector: string): PrimitiveComponent[];
     selectOne(selector: string, options?: {
         type?: string;
@@ -309,6 +313,10 @@ declare class Net extends PrimitiveComponent<typeof netProps> {
      * ports that are connected to each other. If a there are multiple net islands
      * that means that the net is not fully connected and we need to add traces
      * such that the nets are fully connected
+     *
+     * Sometimes this phase doesn't find any net islands if the autorouter did
+     * a good job and connected the islands. In some sense this is a "backup"
+     * routing phase for autorouters that don't care about connecting nets.
      */
     doInitialPcbRouteNetIslands(): void;
 }
@@ -730,13 +738,78 @@ declare class NormalComponent<ZodProps extends ZodType = any, PortNames extends
     doInitialCadModelRender(): void;
 }
 
-declare class Group<Props extends z.ZodType<any, any, any> = typeof groupProps> extends NormalComponent<Props> {
+type SimplifiedPcbTrace = {
+    type: "pcb_trace";
+    pcb_trace_id: string;
+    route: Array<{
+        route_type: "wire";
+        x: number;
+        y: number;
+        width: number;
+        layer: string;
+    } | {
+        route_type: "via";
+        x: number;
+        y: number;
+        to_layer: string;
+        from_layer: string;
+    }>;
+};
+type Obstacle = {
+    type: "rect";
+    layers: string[];
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    connectedTo: string[];
+};
+interface SimpleRouteConnection {
+    name: string;
+    pointsToConnect: Array<{
+        x: number;
+        y: number;
+        layer: string;
+    }>;
+}
+interface SimpleRouteJson {
+    layerCount: number;
+    minTraceWidth: number;
+    obstacles: Obstacle[];
+    connections: Array<SimpleRouteConnection>;
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    traces?: SimplifiedPcbTrace[];
+}
+
+declare class Group<Props extends z.ZodType<any, any, any> = typeof groupProps> extends NormalComponent<Props> implements ISubcircuit {
+    _asyncAutoroutingResult: {
+        output_simple_route_json: SimpleRouteJson;
+    } | null;
     get config(): {
         zodProps: Props;
         componentName: string;
     };
     doInitialCreateTraceHintsFromProps(): void;
+    _getSimpleRouteJsonFromPcbTraces(): SimpleRouteJson;
+    doInitialPcbTraceRender(): void;
+    updatePcbTraceRender(): void;
     doInitialSchematicLayout(): void;
+    /**
+     * Trace-by-trace autorouting is where each trace routes itself in a well-known
+     * order. It's the most deterministic way to autoroute, because a new trace
+     * is generally ordered last.
+     *
+     * This method will return false if using an external service for autorouting
+     * or if using a "fullview" or "rip and replace" autorouting mode
+     */
+    _shouldUseTraceByTraceRouting(): boolean;
 }
 
 declare class Board extends Group<typeof boardProps> {

package/dist/index.js

@@ -903,6 +903,10 @@ var Net = class extends PrimitiveComponent {
    * ports that are connected to each other. If a there are multiple net islands
    * that means that the net is not fully connected and we need to add traces
    * such that the nets are fully connected
+   *
+   * Sometimes this phase doesn't find any net islands if the autorouter did
+   * a good job and connected the islands. In some sense this is a "backup"
+   * routing phase for autorouters that don't care about connecting nets.
    */
   doInitialPcbRouteNetIslands() {
     const { db } = this.root;
@@ -2433,7 +2437,7 @@ var NormalComponent = class extends PrimitiveComponent {
 import { boardProps } from "@tscircuit/props";
 import { identity as identity4 } from "transformation-matrix";
 
-// lib/components/primitive-components/Group.ts
+// lib/components/primitive-components/Group/Group.ts
 import {
   groupProps
 } from "@tscircuit/props";
@@ -2500,9 +2504,11 @@ var TraceHint = class extends PrimitiveComponent {
   }
 };
 
-// lib/components/primitive-components/Group.ts
+// lib/components/primitive-components/Group/Group.ts
 import * as SAL from "@tscircuit/schematic-autolayout";
+import { getObstaclesFromSoup } from "@tscircuit/infgrid-ijump-astar";
 var Group = class extends NormalComponent {
+  _asyncAutoroutingResult = null;
   get config() {
     return {
       zodProps: groupProps,
@@ -2525,6 +2531,87 @@ var Group = class extends NormalComponent {
       );
     }
   }
+  _getSimpleRouteJsonFromPcbTraces() {
+    const traces = this.selectAll("trace");
+    const { db } = this.root;
+    const obstacles = getObstaclesFromSoup([
+      ...db.pcb_component.list(),
+      ...db.pcb_smtpad.list(),
+      ...db.pcb_plated_hole.list()
+    ]);
+    const allPoints = obstacles.flatMap((o) => [
+      {
+        x: o.center.x - o.width / 2,
+        y: o.center.y - o.height / 2
+      },
+      {
+        x: o.center.x + o.width / 2,
+        y: o.center.y + o.height / 2
+      }
+    ]);
+    const bounds = {
+      minX: Math.min(...allPoints.map((p) => p.x)) - 1,
+      maxX: Math.max(...allPoints.map((p) => p.x)) + 1,
+      minY: Math.min(...allPoints.map((p) => p.y)) - 1,
+      maxY: Math.max(...allPoints.map((p) => p.y)) + 1
+    };
+    const connections = traces.map((trace) => {
+      const connectedPorts = trace._findConnectedPorts();
+      if (!connectedPorts.allPortsFound || connectedPorts.ports.length < 2)
+        return null;
+      return {
+        name: trace.source_trace_id ?? "",
+        pointsToConnect: connectedPorts.ports.map((port) => {
+          const pos = port._getGlobalPcbPositionBeforeLayout();
+          return {
+            x: pos.x,
+            y: pos.y,
+            layer: port.getAvailablePcbLayers()[0] ?? "top"
+          };
+        })
+      };
+    }).filter((c) => c !== null);
+    return {
+      bounds,
+      obstacles: [],
+      connections,
+      layerCount: 2,
+      minTraceWidth: this._parsedProps.minTraceWidth ?? 0.1
+    };
+  }
+  doInitialPcbTraceRender() {
+    if (this._shouldUseTraceByTraceRouting()) return;
+    if (this.props.autorouter?.serverUrl) {
+      this._queueAsyncEffect(async () => {
+        const { autorouting_result } = await fetch(
+          this.props.autorouter.serverUrl,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              input_simple_route_json: this._getSimpleRouteJsonFromPcbTraces()
+            })
+          }
+        ).then((r) => r.json());
+        const { output_simple_route_json } = autorouting_result;
+        this._asyncAutoroutingResult = autorouting_result;
+        this._markDirty("PcbTraceRender");
+      });
+    }
+  }
+  updatePcbTraceRender() {
+    if (!this._asyncAutoroutingResult) return;
+    if (this._shouldUseTraceByTraceRouting()) return;
+    const { db } = this.root;
+    const { traces: routedTraces } = this._asyncAutoroutingResult.output_simple_route_json;
+    if (!routedTraces) return;
+    const circuitTraces = this.selectAll("trace");
+    for (const routedTrace of routedTraces) {
+      const pcb_trace = db.pcb_trace.insert({
+        route: routedTrace.route
+        // source_trace_id: circuitTrace.source_trace_id!,
+      });
+    }
+  }
   doInitialSchematicLayout() {
     if (!this.isSubcircuit) return;
     const props = this._parsedProps;
@@ -2551,6 +2638,18 @@ var Group = class extends NormalComponent {
     const laidOutScene = SAL.ascendingCentralLrBug1(scene);
     SAL.mutateSoupForScene(db.toArray(), laidOutScene);
   }
+  /**
+   * Trace-by-trace autorouting is where each trace routes itself in a well-known
+   * order. It's the most deterministic way to autoroute, because a new trace
+   * is generally ordered last.
+   *
+   * This method will return false if using an external service for autorouting
+   * or if using a "fullview" or "rip and replace" autorouting mode
+   */
+  _shouldUseTraceByTraceRouting() {
+    if (this.props.autorouter) return false;
+    return true;
+  }
 };
 
 // lib/components/normal-components/Board.ts
@@ -2617,7 +2716,7 @@ var FTYPE = stringProxy;
 // lib/components/primitive-components/Trace.ts
 import {
   MultilayerIjump,
-  getObstaclesFromSoup
+  getObstaclesFromSoup as getObstaclesFromSoup2
 } from "@tscircuit/infgrid-ijump-astar";
 import { traceProps } from "@tscircuit/props";
 import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
@@ -2998,6 +3097,9 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
     if (this.getSubcircuit()._parsedProps.routingDisabled) {
       return;
     }
+    if (!this.getSubcircuit()._shouldUseTraceByTraceRouting()) {
+      return;
+    }
     const { allPortsFound, ports } = this._findConnectedPorts();
     const portsConnectedOnPcbViaNet = [];
     if (!allPortsFound) return;
@@ -3094,7 +3196,7 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
       this.root.db.toArray()
     );
     const [obstacles, errGettingObstacles] = tryNow(
-      () => getObstaclesFromSoup(this.root.db.toArray())
+      () => getObstaclesFromSoup2(this.root.db.toArray())
       // Remove as any when autorouting-dataset gets updated
     );
     if (errGettingObstacles) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.134",
+  "version": "0.0.135",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",