@tscircuit/core 0.0.133 → 0.0.135

package/dist/index.d.ts

@@ -13,6 +13,7 @@ type RenderPhase = (typeof orderedRenderPhases)[number];
 type RenderPhaseFn<K extends RenderPhase = RenderPhase> = `doInitial${K}` | `update${K}` | `remove${K}`;
 type RenderPhaseStates = Record<RenderPhase, {
     initialized: boolean;
+    dirty: boolean;
 }>;
 type RenderPhaseFunctions = {
     [T in RenderPhaseFn]?: () => void;
@@ -34,7 +35,12 @@ declare abstract class Renderable implements IRenderable {
     /** Schematic-only, lines, boxes, indicators etc. */
     isSchematicPrimitive: boolean;
     _renderId: string;
+    _currentRenderPhase: RenderPhase | null;
+    private _asyncEffects;
     constructor(props: any);
+    protected _markDirty(phase: RenderPhase): void;
+    protected _queueAsyncEffect(effect: () => Promise<void>): void;
+    _hasIncompleteAsyncEffects(): boolean;
     runRenderCycle(): void;
     /**
      * This runs all the render methods for a given phase, calling one of:
@@ -53,6 +59,7 @@ type ReactSubtree = {
     component: NormalComponent;
 };
 
+type RootCircuitEventName = "asyncEffectComplete";
 declare class Circuit {
     firstChild: PrimitiveComponent | null;
     children: PrimitiveComponent[];
@@ -71,6 +78,8 @@ declare class Circuit {
     };
     _guessRootComponent(): void;
     render(): void;
+    renderUntilSettled(): Promise<void>;
+    private _hasIncompleteAsyncEffects;
     getSoup(): AnyCircuitElement[];
     getCircuitJson(): AnyCircuitElement[];
     toJson(): AnyCircuitElement[];
@@ -88,12 +97,19 @@ declare class Circuit {
     selectOne(selector: string, opts?: {
         type?: "component" | "port";
     }): PrimitiveComponent | null;
+    _eventListeners: Record<RootCircuitEventName, Array<(...args: any[]) => void>>;
+    emit(event: RootCircuitEventName, ...args: any[]): void;
+    on(event: RootCircuitEventName, listener: (...args: any[]) => void): void;
 }
 /**
  * @deprecated
  */
 declare const Project: typeof Circuit;
 
+interface ISubcircuit extends PrimitiveComponent {
+    _shouldUseTraceByTraceRouting(): boolean;
+}
+
 interface BaseComponentConfig {
     componentName: string;
     schematicSymbolName?: BaseSymbolName | null;
@@ -244,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;
@@ -297,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;
 }
@@ -718,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

@@ -87,14 +87,61 @@ var Renderable = class {
   /** Schematic-only, lines, boxes, indicators etc. */
   isSchematicPrimitive = false;
   _renderId;
+  _currentRenderPhase = null;
+  _asyncEffects = [];
   constructor(props) {
     this._renderId = `${globalRenderCounter++}`;
     this.children = [];
     this.renderPhaseStates = {};
     for (const phase of orderedRenderPhases) {
-      this.renderPhaseStates[phase] = { initialized: false };
+      this.renderPhaseStates[phase] = {
+        initialized: false,
+        dirty: false
+      };
+    }
+  }
+  _markDirty(phase) {
+    this.renderPhaseStates[phase].dirty = true;
+    const phaseIndex = orderedRenderPhases.indexOf(phase);
+    for (let i = phaseIndex + 1; i < orderedRenderPhases.length; i++) {
+      this.renderPhaseStates[orderedRenderPhases[i]].dirty = true;
     }
   }
+  _queueAsyncEffect(effect) {
+    const asyncEffect = {
+      promise: effect(),
+      // TODO don't start effects until end of render cycle
+      phase: this._currentRenderPhase,
+      complete: false
+    };
+    this._asyncEffects.push(asyncEffect);
+    asyncEffect.promise.then(() => {
+      asyncEffect.complete = true;
+      if ("root" in this && this.root) {
+        ;
+        this.root.emit("asyncEffectComplete", {
+          component: this,
+          asyncEffect
+        });
+      }
+    }).catch((error) => {
+      console.error(
+        `Async effect error in ${this._currentRenderPhase}:`,
+        error
+      );
+      asyncEffect.complete = true;
+      if ("root" in this && this.root) {
+        ;
+        this.root.emit("asyncEffectComplete", {
+          component: this,
+          asyncEffect
+        });
+      }
+    });
+  }
+  _hasIncompleteAsyncEffects() {
+    return this._asyncEffects.some((effect) => !effect.complete);
+  }
   runRenderCycle() {
     for (const renderPhase of orderedRenderPhases) {
       this.runRenderPhaseForChildren(renderPhase);
@@ -109,22 +156,35 @@ var Renderable = class {
    *  ...depending on the current state of the component.
    */
   runRenderPhase(phase) {
-    const isInitialized = this.renderPhaseStates[phase].initialized;
+    this._currentRenderPhase = phase;
+    const phaseState = this.renderPhaseStates[phase];
+    const isInitialized = phaseState.initialized;
+    const isDirty = phaseState.dirty;
     if (!isInitialized && this.shouldBeRemoved) return;
     if (this.shouldBeRemoved && isInitialized) {
       ;
       this?.[`remove${phase}`]?.();
-      this.renderPhaseStates[phase].initialized = false;
+      phaseState.initialized = false;
+      phaseState.dirty = false;
       return;
     }
+    const prevPhaseIndex = orderedRenderPhases.indexOf(phase) - 1;
+    if (prevPhaseIndex >= 0) {
+      const prevPhase = orderedRenderPhases[prevPhaseIndex];
+      const hasIncompleteEffects = this._asyncEffects.filter((e) => e.phase === prevPhase).some((e) => !e.complete);
+      if (hasIncompleteEffects) return;
+    }
     if (isInitialized) {
-      ;
-      this?.[`update${phase}`]?.();
+      if (isDirty) {
+        ;
+        this?.[`update${phase}`]?.();
+        phaseState.dirty = false;
+      }
       return;
     }
-    ;
+    phaseState.dirty = false;
     this?.[`doInitial${phase}`]?.();
-    this.renderPhaseStates[phase].initialized = true;
+    phaseState.initialized = true;
   }
   runRenderPhaseForChildren(phase) {
     for (const child of this.children) {
@@ -843,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;
@@ -2373,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";
@@ -2440,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,
@@ -2465,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;
@@ -2491,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
@@ -2557,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";
@@ -2938,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;
@@ -3034,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) {
@@ -4396,6 +4558,21 @@ var Circuit = class {
     firstChild.runRenderCycle();
     this._hasRenderedAtleastOnce = true;
   }
+  async renderUntilSettled() {
+    this.render();
+    while (this._hasIncompleteAsyncEffects()) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      this.render();
+    }
+  }
+  _hasIncompleteAsyncEffects() {
+    return this.children.some((child) => {
+      if (child._hasIncompleteAsyncEffects()) return true;
+      return child.children.some(
+        (grandchild) => grandchild._hasIncompleteAsyncEffects()
+      );
+    });
+  }
   getSoup() {
     if (!this._hasRenderedAtleastOnce) this.render();
     return this.db.toArray();
@@ -4432,6 +4609,19 @@ var Circuit = class {
   selectOne(selector, opts) {
     return this.firstChild?.selectOne(selector, opts) ?? null;
   }
+  _eventListeners = { asyncEffectComplete: [] };
+  emit(event, ...args) {
+    if (!this._eventListeners[event]) return;
+    for (const listener of this._eventListeners[event]) {
+      listener(...args);
+    }
+  }
+  on(event, listener) {
+    if (!this._eventListeners[event]) {
+      this._eventListeners[event] = [];
+    }
+    this._eventListeners[event].push(listener);
+  }
 };
 var Project = Circuit;
 

package/package.json

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