@tscircuit/core 0.0.132 → 0.0.134

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,6 +97,9 @@ 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

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) {
@@ -1543,9 +1603,10 @@ var Port = class extends PrimitiveComponent {
       console.warn(`Could not find parent symbol for ${this}`);
       return { x: 0, y: 0 };
     }
+    const offsetY = -0.045;
     const transform = compose3(
       this.parent.computeSchematicGlobalTransform(),
-      translate3(-symbol.center.x, -symbol.center.y)
+      translate3(-symbol.center.x, -symbol.center.y + offsetY)
     );
     return applyToPoint4(transform, this.schematicSymbolPortDef);
   }
@@ -2554,11 +2615,49 @@ var stringProxy = new Proxy(
 var FTYPE = stringProxy;
 
 // lib/components/primitive-components/Trace.ts
-import { traceProps } from "@tscircuit/props";
 import {
   MultilayerIjump,
   getObstaclesFromSoup
 } from "@tscircuit/infgrid-ijump-astar";
+import { traceProps } from "@tscircuit/props";
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+
+// lib/utils/autorouting/DirectLineRouter.ts
+var DirectLineRouter = class {
+  input;
+  constructor({ input }) {
+    this.input = input;
+  }
+  solveAndMapToTraces() {
+    const traces = [];
+    for (const connection of this.input.connections) {
+      if (connection.pointsToConnect.length !== 2) continue;
+      const [start, end] = connection.pointsToConnect;
+      const trace = {
+        type: "pcb_trace",
+        pcb_trace_id: "",
+        route: [
+          {
+            route_type: "wire",
+            x: start.x,
+            y: start.y,
+            layer: "top",
+            width: 0.1
+          },
+          {
+            route_type: "wire",
+            x: end.x,
+            y: end.y,
+            layer: "top",
+            width: 0.1
+          }
+        ]
+      };
+      traces.push(trace);
+    }
+    return traces;
+  }
+};
 
 // lib/utils/autorouting/computeObstacleBounds.ts
 var computeObstacleBounds = (obstacles) => {
@@ -2569,22 +2668,6 @@ var computeObstacleBounds = (obstacles) => {
   return { minX, maxX, minY, maxY };
 };
 
-// lib/utils/projectPointInDirection.ts
-var projectPointInDirection = (point, direction, distance) => {
-  switch (direction) {
-    case "up":
-      return { x: point.x, y: point.y - distance };
-    case "down":
-      return { x: point.x, y: point.y + distance };
-    case "left":
-      return { x: point.x - distance, y: point.y };
-    case "right":
-      return { x: point.x + distance, y: point.y };
-    default:
-      throw new Error(`Unknown direction "${direction}"`);
-  }
-};
-
 // lib/utils/autorouting/findPossibleTraceLayerCombinations.ts
 var LAYER_SELECTION_PREFERENCE = ["top", "bottom", "inner1", "inner2"];
 var findPossibleTraceLayerCombinations = (hints, layer_path = []) => {
@@ -2718,8 +2801,37 @@ function getClosest(point, candidates) {
   return closest;
 }
 
-// lib/components/primitive-components/Trace.ts
-import "zod";
+// lib/utils/projectPointInDirection.ts
+var projectPointInDirection = (point, direction, distance) => {
+  switch (direction) {
+    case "up":
+      return { x: point.x, y: point.y + distance };
+    case "down":
+      return { x: point.x, y: point.y - distance };
+    case "left":
+      return { x: point.x + distance, y: point.y };
+    case "right":
+      return { x: point.x - distance, y: point.y };
+    default:
+      throw new Error(`Unknown direction "${direction}"`);
+  }
+};
+
+// lib/utils/projectPointInOppositeDirection.ts
+var projectPointInOppositeDirection = (point, direction, distance) => {
+  switch (direction) {
+    case "up":
+      return { x: point.x, y: point.y + distance };
+    case "down":
+      return { x: point.x, y: point.y - distance };
+    case "left":
+      return { x: point.x + distance, y: point.y };
+    case "right":
+      return { x: point.x - distance, y: point.y };
+    default:
+      throw new Error(`Unknown direction "${direction}"`);
+  }
+};
 
 // lib/utils/try-now.ts
 function tryNow(fn) {
@@ -2731,46 +2843,7 @@ function tryNow(fn) {
 }
 
 // lib/components/primitive-components/Trace.ts
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
-
-// lib/utils/autorouting/DirectLineRouter.ts
-var DirectLineRouter = class {
-  input;
-  constructor({ input }) {
-    this.input = input;
-  }
-  solveAndMapToTraces() {
-    const traces = [];
-    for (const connection of this.input.connections) {
-      if (connection.pointsToConnect.length !== 2) continue;
-      const [start, end] = connection.pointsToConnect;
-      const trace = {
-        type: "pcb_trace",
-        pcb_trace_id: "",
-        route: [
-          {
-            route_type: "wire",
-            x: start.x,
-            y: start.y,
-            layer: "top",
-            width: 0.1
-          },
-          {
-            route_type: "wire",
-            x: end.x,
-            y: end.y,
-            layer: "top",
-            width: 0.1
-          }
-        ]
-      };
-      traces.push(trace);
-    }
-    return traces;
-  }
-};
-
-// lib/components/primitive-components/Trace.ts
+import "zod";
 var portToObjective = (port) => {
   const portPosition = port._getGlobalPcbPositionAfterLayout();
   return {
@@ -3204,17 +3277,19 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
         });
       }
     }
-    for (const { port } of ports) {
-      connection.pointsToConnect.push({
-        ...port._getGlobalSchematicPositionAfterLayout(),
-        ...projectPointInDirection(
-          port._getGlobalSchematicPositionAfterLayout(),
-          port.facingDirection,
-          0.1501
-        ),
-        layer: "top"
-      });
+    const portsWithPosition = ports.map(({ port }) => ({
+      port,
+      position: port._getGlobalSchematicPositionAfterLayout(),
+      schematic_port_id: port.schematic_port_id ?? void 0,
+      facingDirection: port.facingDirection
+    }));
+    if (portsWithPosition.length < 2) {
+      return;
     }
+    connection.pointsToConnect = portsWithPosition.map(({ position }) => ({
+      ...position,
+      layer: "top"
+    }));
     const bounds = computeObstacleBounds(obstacles);
     const simpleRouteJsonInput = {
       minTraceWidth: 0.1,
@@ -3223,19 +3298,6 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
       bounds,
       layerCount: 1
     };
-    if (this.getSubcircuit().props._schDebugObjectsEnabled) {
-      for (const obstacle of obstacles) {
-        db.schematic_debug_object.insert({
-          shape: "rect",
-          center: obstacle.center,
-          size: {
-            width: obstacle.width,
-            height: obstacle.height
-          },
-          label: "obstacle"
-        });
-      }
-    }
     let Autorouter = MultilayerIjump;
     if (this.getSubcircuit().props._schDirectLineRoutingEnabled) {
       Autorouter = DirectLineRouter;
@@ -3250,14 +3312,34 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
     const { route } = result;
     const edges = [];
     for (let i = 0; i < route.length - 1; i++) {
-      const from = route[i];
-      const to = route[i + 1];
       edges.push({
-        from,
-        to
-        // TODO to_schematic_port_id and from_schematic_port_id
+        from: route[i],
+        to: route[i + 1]
       });
     }
+    const STUB_LENGTH = 0.15;
+    edges.unshift({
+      from: {
+        ...projectPointInDirection(
+          route[0],
+          portsWithPosition[0].facingDirection,
+          STUB_LENGTH
+        )
+      },
+      to: route[0],
+      from_schematic_port_id: portsWithPosition[0].schematic_port_id
+    });
+    edges.push({
+      from: route[route.length - 1],
+      to: {
+        ...projectPointInOppositeDirection(
+          route[route.length - 1],
+          portsWithPosition[1].facingDirection,
+          STUB_LENGTH
+        )
+      },
+      from_schematic_port_id: portsWithPosition[1].schematic_port_id
+    });
     const trace = db.schematic_trace.insert({
       source_trace_id: this.source_trace_id,
       edges
@@ -4374,6 +4456,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();
@@ -4410,6 +4507,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.132",
+  "version": "0.0.134",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",