@tscircuit/core 0.0.841 → 0.0.843

package/dist/index.d.ts

@@ -55,9 +55,10 @@ declare abstract class Renderable implements IRenderable {
     protected _emitRenderLifecycleEvent(phase: RenderPhase, startOrEnd: "start" | "end"): void;
     getString(): string;
     _hasIncompleteAsyncEffects(): boolean;
-    private _hasIncompleteAsyncEffectsInSubtreeForPhase;
+    _hasIncompleteAsyncEffectsInSubtreeForPhase(phase: RenderPhase): boolean;
     getCurrentRenderPhase(): RenderPhase | null;
     getRenderGraph(): Record<string, any>;
+    getTopLevelRenderable(): Renderable;
     runRenderCycle(): void;
     /**
      * This runs all the render methods for a given phase, calling one of:
@@ -24638,21 +24639,21 @@ declare class CopperPour extends PrimitiveComponent<typeof copperPourProps> {
     isPcbPrimitive: boolean;
     get config(): {
         componentName: string;
-        zodProps: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            layer: z.ZodEffects<z.ZodUnion<[z.ZodEnum<["top", "bottom", "inner1", "inner2", "inner3", "inner4", "inner5", "inner6"]>, z.ZodObject<{
-                name: z.ZodEnum<["top", "bottom", "inner1", "inner2", "inner3", "inner4", "inner5", "inner6"]>;
-            }, "strip", z.ZodTypeAny, {
+        zodProps: zod.ZodObject<{
+            name: zod.ZodOptional<zod.ZodString>;
+            layer: zod.ZodEffects<zod.ZodUnion<[zod.ZodEnum<["top", "bottom", "inner1", "inner2", "inner3", "inner4", "inner5", "inner6"]>, zod.ZodObject<{
+                name: zod.ZodEnum<["top", "bottom", "inner1", "inner2", "inner3", "inner4", "inner5", "inner6"]>;
+            }, "strip", zod.ZodTypeAny, {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }, {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }>]>, "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6", "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6" | {
                 name: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             }>;
-            connectsTo: z.ZodString;
-            padMargin: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
-            traceMargin: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>>;
-        }, "strip", z.ZodTypeAny, {
+            connectsTo: zod.ZodString;
+            padMargin: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
+            traceMargin: zod.ZodOptional<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>, number, string | number>>;
+        }, "strip", zod.ZodTypeAny, {
             layer: "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
             connectsTo: string;
             name?: string | undefined;

package/dist/index.js

@@ -174,7 +174,7 @@ var asyncPhaseDependencies = {
   PcbComponentAnchorAlignment: ["PcbFootprintStringRender"]
 };
 var globalRenderCounter = 0;
-var Renderable = class {
+var Renderable = class _Renderable {
   renderPhaseStates;
   shouldBeRemoved = false;
   children;
@@ -299,6 +299,13 @@ ${error.stack}`
       )
     };
   }
+  getTopLevelRenderable() {
+    let current = this;
+    while (current.parent && current.parent instanceof _Renderable) {
+      current = current.parent;
+    }
+    return current;
+  }
   runRenderCycle() {
     for (const renderPhase of orderedRenderPhases) {
       this.runRenderPhaseForChildren(renderPhase);
@@ -333,8 +340,13 @@ ${error.stack}`
       if (hasIncompleteEffects) return;
     }
     const deps = asyncPhaseDependencies[phase] || [];
-    for (const depPhase of deps) {
-      if (this._hasIncompleteAsyncEffectsInSubtreeForPhase(depPhase)) return;
+    if (deps.length > 0) {
+      const root = this.getTopLevelRenderable();
+      for (const depPhase of deps) {
+        if (root._hasIncompleteAsyncEffectsInSubtreeForPhase(depPhase)) {
+          return;
+        }
+      }
     }
     this._emitRenderLifecycleEvent(phase, "start");
     if (isInitialized) {
@@ -16302,11 +16314,218 @@ var Via = class extends PrimitiveComponent2 {
   }
 };
 
-// lib/components/primitive-components/CopperPour.ts
+// lib/components/primitive-components/CopperPour/CopperPour.ts
 import { copperPourProps } from "@tscircuit/props";
-import "zod";
-import Flatten from "@flatten-js/core";
 import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson4 } from "circuit-json-to-connectivity-map";
+import Flatten4 from "@flatten-js/core";
+
+// lib/components/primitive-components/CopperPour/utils/get-board-polygon.ts
+import Flatten from "@flatten-js/core";
+var getBoardPolygon = (board) => {
+  if (board.outline && board.outline.length > 0) {
+    return new Flatten.Polygon(
+      board.outline.map((p) => Flatten.point(p.x, p.y))
+    );
+  }
+  return new Flatten.Polygon(
+    new Flatten.Box(
+      board.center.x - board.width / 2,
+      board.center.y - board.height / 2,
+      board.center.x + board.width / 2,
+      board.center.y + board.height / 2
+    ).toPoints()
+  );
+};
+
+// lib/components/primitive-components/CopperPour/utils/get-trace-obstacles.ts
+var getTraceObstacles = (db, layer) => {
+  const traceObstacles = [];
+  for (const pcb_trace of db.pcb_trace.list()) {
+    if (!pcb_trace.route) continue;
+    const source_trace = pcb_trace.source_trace_id ? db.source_trace.get(pcb_trace.source_trace_id) : null;
+    const connectedToIds = /* @__PURE__ */ new Set();
+    if (pcb_trace.source_trace_id) {
+      connectedToIds.add(pcb_trace.source_trace_id);
+    }
+    if (source_trace) {
+      for (const id of source_trace.connected_source_net_ids)
+        connectedToIds.add(id);
+      for (const id of source_trace.connected_source_port_ids)
+        connectedToIds.add(id);
+    }
+    for (const pt of pcb_trace.route) {
+      if (pt.route_type === "wire") {
+        if (pt.start_pcb_port_id) {
+          const pcb_port = db.pcb_port.get(pt.start_pcb_port_id);
+          if (pcb_port?.source_port_id)
+            connectedToIds.add(pcb_port.source_port_id);
+        }
+        if (pt.end_pcb_port_id) {
+          const pcb_port = db.pcb_port.get(pt.end_pcb_port_id);
+          if (pcb_port?.source_port_id)
+            connectedToIds.add(pcb_port.source_port_id);
+        }
+      }
+    }
+    const connectedTo = Array.from(connectedToIds);
+    for (let i = 0; i < pcb_trace.route.length - 1; i++) {
+      const p1 = pcb_trace.route[i];
+      const p2 = pcb_trace.route[i + 1];
+      if (p1.route_type !== "wire" || p2.route_type !== "wire") continue;
+      if (p1.layer !== layer) continue;
+      const segmentWidth = p1.width;
+      if (segmentWidth === 0) continue;
+      const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
+      if (segmentLength === 0) continue;
+      const centerX = (p1.x + p2.x) / 2;
+      const centerY = (p1.y + p2.y) / 2;
+      const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
+      const rotatedRect = {
+        center: { x: centerX, y: centerY },
+        width: segmentLength,
+        height: segmentWidth,
+        rotation: rotationDeg
+      };
+      const approximatingRects = generateApproximatingRects(rotatedRect);
+      for (const rect of approximatingRects) {
+        traceObstacles.push({
+          type: "rect",
+          layers: [p1.layer],
+          center: rect.center,
+          width: rect.width,
+          height: rect.height,
+          connectedTo,
+          obstacle_type: "trace"
+        });
+      }
+    }
+  }
+  return traceObstacles;
+};
+
+// lib/components/primitive-components/CopperPour/utils/process-obstacles.ts
+import Flatten2 from "@flatten-js/core";
+var processObstaclesForPour = (obstacles, connMap, net, margins) => {
+  const rectObstaclesToSubtract = [];
+  const circularObstacles = [];
+  const { traceMargin, padMargin } = margins;
+  for (const obs of obstacles) {
+    const isOnNet = obs.connectedTo.some(
+      (id) => connMap.areIdsConnected(id, net.source_net_id)
+    );
+    if (isOnNet) {
+      continue;
+    }
+    if (obs.type === "oval" && obs.width === obs.height) {
+      const radius = obs.width / 2 + padMargin;
+      circularObstacles.push({
+        center: obs.center,
+        radius
+      });
+      continue;
+    }
+    if (obs.type === "rect" && obs.width === obs.height && obs.connectedTo.length === 0) {
+      const radius = obs.width / 2;
+      circularObstacles.push({
+        center: obs.center,
+        radius
+      });
+      continue;
+    }
+    const margin = traceMargin;
+    const b = new Flatten2.Box(
+      obs.center.x - obs.width / 2 - margin,
+      obs.center.y - obs.height / 2 - margin,
+      obs.center.x + obs.width / 2 + margin,
+      obs.center.y + obs.height / 2 + margin
+    );
+    rectObstaclesToSubtract.push(new Flatten2.Polygon(b.toPoints()));
+  }
+  return { rectObstaclesToSubtract, circularObstacles };
+};
+
+// lib/components/primitive-components/CopperPour/utils/generate-and-insert-brep.ts
+import Flatten3 from "@flatten-js/core";
+var faceToVertices = (face) => face.edges.map((e) => {
+  const pt = {
+    x: e.start.x,
+    y: e.start.y
+  };
+  if (e.isArc) {
+    const bulge = Math.tan(e.shape.sweep / 4);
+    if (Math.abs(bulge) > 1e-9) {
+      pt.bulge = bulge;
+    }
+  }
+  return pt;
+});
+var generateAndInsertBRep = (pourPolygons, circularObstacles, {
+  db,
+  copperPour
+}) => {
+  const props = copperPour._parsedProps;
+  const net = copperPour.getSubcircuit().selectOne(props.connectsTo);
+  const subcircuit = copperPour.getSubcircuit();
+  const polygons = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons];
+  for (const p of polygons) {
+    const islands = p.splitToIslands();
+    for (const island of islands) {
+      if (island.isEmpty()) continue;
+      const faces = [...island.faces];
+      const outer_face_ccw = faces.find(
+        (f) => f.orientation() === Flatten3.ORIENTATION.CCW
+      );
+      const inner_faces_cw = faces.filter(
+        (f) => f.orientation() === Flatten3.ORIENTATION.CW
+      );
+      if (!outer_face_ccw) continue;
+      if (!db.pcb_copper_pour) {
+        copperPour.renderError(
+          "db.pcb_copper_pour not found. The database schema may be outdated."
+        );
+        return;
+      }
+      outer_face_ccw.reverse();
+      const outer_ring_vertices = faceToVertices(outer_face_ccw);
+      const inner_rings = inner_faces_cw.map((f) => {
+        f.reverse();
+        return { vertices: faceToVertices(f) };
+      });
+      for (const circle of circularObstacles) {
+        const centerPoint = Flatten3.point(circle.center.x, circle.center.y);
+        const isContained = island.contains(centerPoint);
+        if (isContained) {
+          inner_rings.push({
+            vertices: [
+              {
+                x: circle.center.x,
+                y: circle.center.y - circle.radius,
+                bulge: 1
+              },
+              {
+                x: circle.center.x,
+                y: circle.center.y + circle.radius,
+                bulge: 1
+              }
+            ]
+          });
+        }
+      }
+      db.pcb_copper_pour.insert({
+        shape: "brep",
+        layer: props.layer,
+        brep_shape: {
+          outer_ring: { vertices: outer_ring_vertices },
+          inner_rings
+        },
+        source_net_id: net.source_net_id,
+        subcircuit_id: subcircuit?.subcircuit_id ?? void 0
+      });
+    }
+  }
+};
+
+// lib/components/primitive-components/CopperPour/CopperPour.ts
 var CopperPour = class extends PrimitiveComponent2 {
   isPcbPrimitive = true;
   get config() {
@@ -16333,180 +16552,33 @@ var CopperPour = class extends PrimitiveComponent2 {
         this.renderError("No board found for copper pour");
         return;
       }
-      let boardPolygon;
-      if (board.outline && board.outline.length > 0) {
-        boardPolygon = new Flatten.Polygon(
-          board.outline.map((p) => Flatten.point(p.x, p.y))
-        );
-      } else {
-        boardPolygon = new Flatten.Polygon(
-          new Flatten.Box(
-            board.center.x - board.width / 2,
-            board.center.y - board.height / 2,
-            board.center.x + board.width / 2,
-            board.center.y + board.height / 2
-          ).toPoints()
-        );
-      }
+      const boardPolygon = getBoardPolygon(board);
       const connMap = getFullConnectivityMapFromCircuitJson4(db.toArray());
       const obstaclesRaw = getObstaclesFromCircuitJson(
         db.toArray(),
         connMap
       ).filter((o) => o.layers.includes(props.layer));
-      for (const pcb_trace of db.pcb_trace.list()) {
-        if (!pcb_trace.route) continue;
-        for (let i = 0; i < pcb_trace.route.length - 1; i++) {
-          const p1 = pcb_trace.route[i];
-          const p2 = pcb_trace.route[i + 1];
-          if (p1.route_type !== "wire" || p2.route_type !== "wire") continue;
-          if (p1.layer !== props.layer) continue;
-          const segmentWidth = p1.width;
-          if (segmentWidth === 0) continue;
-          const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
-          if (segmentLength === 0) continue;
-          const centerX = (p1.x + p2.x) / 2;
-          const centerY = (p1.y + p2.y) / 2;
-          const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
-          const rotatedRect = {
-            center: { x: centerX, y: centerY },
-            width: segmentLength,
-            height: segmentWidth,
-            rotation: rotationDeg
-          };
-          const approximatingRects = generateApproximatingRects(rotatedRect);
-          for (const rect of approximatingRects) {
-            obstaclesRaw.push({
-              type: "rect",
-              layers: [p1.layer],
-              center: rect.center,
-              width: rect.width,
-              height: rect.height,
-              connectedTo: pcb_trace.source_trace_id ? [pcb_trace.source_trace_id] : [],
-              obstacle_type: "trace"
-            });
-          }
-        }
-      }
-      const rectObstaclesToSubtract = [];
-      const circularObstacles = [];
-      const traceMargin = props.traceMargin ?? 0.2;
-      const padMargin = props.padMargin ?? 0.2;
-      for (const obs of obstaclesRaw) {
-        const isOnNet = obs.connectedTo.some(
-          (id) => connMap.areIdsConnected(id, net.source_net_id)
-        );
-        if (isOnNet) {
-          continue;
-        }
-        if (obs.type === "oval" && obs.width === obs.height) {
-          const radius = obs.width / 2 + padMargin;
-          circularObstacles.push({
-            center: obs.center,
-            radius
-          });
-          continue;
-        }
-        if (obs.type === "rect" && obs.width === obs.height && obs.connectedTo.length === 0) {
-          const radius = obs.width / 2;
-          circularObstacles.push({
-            center: obs.center,
-            radius
-          });
-          continue;
-        }
-        const margin = traceMargin;
-        const b = new Flatten.Box(
-          obs.center.x - obs.width / 2 - margin,
-          obs.center.y - obs.height / 2 - margin,
-          obs.center.x + obs.width / 2 + margin,
-          obs.center.y + obs.height / 2 + margin
-        );
-        rectObstaclesToSubtract.push(new Flatten.Polygon(b.toPoints()));
-      }
+      obstaclesRaw.push(...getTraceObstacles(db, props.layer));
+      const { rectObstaclesToSubtract, circularObstacles } = processObstaclesForPour(obstaclesRaw, connMap, net, {
+        traceMargin: props.traceMargin ?? 0.2,
+        padMargin: props.padMargin ?? 0.2
+      });
       let pourPolygons = boardPolygon;
       if (rectObstaclesToSubtract.length > 0) {
         const obstacleUnion = rectObstaclesToSubtract.reduce(
-          (acc, p) => Flatten.BooleanOperations.unify(acc, p)
+          (acc, p) => Flatten4.BooleanOperations.unify(acc, p)
         );
         if (obstacleUnion && !obstacleUnion.isEmpty()) {
-          pourPolygons = Flatten.BooleanOperations.subtract(
+          pourPolygons = Flatten4.BooleanOperations.subtract(
             boardPolygon,
             obstacleUnion
           );
         }
       }
-      if (!Array.isArray(pourPolygons)) {
-        pourPolygons = [pourPolygons];
-      }
-      for (const p of pourPolygons) {
-        const islands = p.splitToIslands();
-        for (const island of islands) {
-          if (island.isEmpty()) continue;
-          const faces = [...island.faces];
-          const outer_face_ccw = faces.find(
-            (f) => f.orientation() === Flatten.ORIENTATION.CCW
-          );
-          const inner_faces_cw = faces.filter(
-            (f) => f.orientation() === Flatten.ORIENTATION.CW
-          );
-          if (!outer_face_ccw) continue;
-          if (!db.pcb_copper_pour) {
-            this.renderError(
-              "db.pcb_copper_pour not found. The database schema may be outdated."
-            );
-            return;
-          }
-          const faceToVertices = (face) => face.edges.map((e) => {
-            const pt = {
-              x: e.start.x,
-              y: e.start.y
-            };
-            if (e.isArc) {
-              const bulge = Math.tan(e.shape.sweep / 4);
-              if (Math.abs(bulge) > 1e-9) {
-                pt.bulge = bulge;
-              }
-            }
-            return pt;
-          });
-          outer_face_ccw.reverse();
-          const outer_ring_vertices = faceToVertices(outer_face_ccw);
-          const inner_rings = inner_faces_cw.map((f) => {
-            f.reverse();
-            return { vertices: faceToVertices(f) };
-          });
-          for (const circle of circularObstacles) {
-            const centerPoint = Flatten.point(circle.center.x, circle.center.y);
-            const isContained = island.contains(centerPoint);
-            if (isContained) {
-              inner_rings.push({
-                vertices: [
-                  {
-                    x: circle.center.x,
-                    y: circle.center.y - circle.radius,
-                    bulge: 1
-                  },
-                  {
-                    x: circle.center.x,
-                    y: circle.center.y + circle.radius,
-                    bulge: 1
-                  }
-                ]
-              });
-            }
-          }
-          db.pcb_copper_pour.insert({
-            shape: "brep",
-            layer: props.layer,
-            brep_shape: {
-              outer_ring: { vertices: outer_ring_vertices },
-              inner_rings
-            },
-            source_net_id: net.source_net_id,
-            subcircuit_id: this.getSubcircuit()?.subcircuit_id ?? void 0
-          });
-        }
-      }
+      generateAndInsertBRep(pourPolygons, circularObstacles, {
+        db,
+        copperPour: this
+      });
     });
   }
 };
@@ -17749,7 +17821,7 @@ import { identity as identity6 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.840",
+  version: "0.0.842",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

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