@tscircuit/core 0.0.1043 → 0.0.1044

package/dist/index.d.ts

@@ -296,6 +296,11 @@ declare class IsolatedCircuit {
      * for subcircuit rendering.
      */
     cachedSubcircuits?: Map<string, AnyCircuitElement[]>;
+    /**
+     * Map to track pending renders by prop hash. This allows multiple subcircuits
+     * with the same props to wait for a single render instead of each doing their own.
+     */
+    pendingSubcircuitRenders?: Map<string, Promise<AnyCircuitElement[]>>;
     private _schematicDisabledOverride;
     get schematicDisabled(): boolean;
     set schematicDisabled(value: boolean);
@@ -318,10 +323,11 @@ declare class IsolatedCircuit {
     _hasRenderedAtleastOnce: boolean;
     private _asyncEffectIdsByPhase;
     private _asyncEffectPhaseById;
-    constructor({ platform, projectUrl, cachedSubcircuits, }?: {
+    constructor({ platform, projectUrl, cachedSubcircuits, pendingSubcircuitRenders, }?: {
         platform?: PlatformConfig;
         projectUrl?: string;
         cachedSubcircuits?: Map<string, AnyCircuitElement[]>;
+        pendingSubcircuitRenders?: Map<string, Promise<AnyCircuitElement[]>>;
     });
     add(componentOrElm: PrimitiveComponent | ReactElement): void;
     setPlatform(platform: Partial<PlatformConfig>): void;

package/dist/index.js

@@ -580,6 +580,9 @@ ${error.stack}`
   }
   runRenderPhaseForChildren(phase) {
     for (const child of this.children) {
+      if ("_isIsolatedSubcircuit" in this && this._isIsolatedSubcircuit && phase === "RenderIsolatedSubcircuits") {
+        continue;
+      }
       child.runRenderPhaseForChildren(phase);
       child.runRenderPhase(phase);
     }
@@ -16915,7 +16918,6 @@ function inflateSourceTrace(sourceTrace, inflatorContext) {
     traceProps2.pcbStraightLine = true;
   }
   const trace = new Trace3(traceProps2);
-  trace.source_trace_id = sourceTrace.source_trace_id;
   subcircuit.add(trace);
 }
 
@@ -17012,8 +17014,22 @@ var inflateCircuitJson = (target, circuitJson, children) => {
     groupsMap
   };
   const sourceGroups = injectionDb.source_group.list();
-  for (const sourceGroup of sourceGroups) {
-    inflateSourceGroup(sourceGroup, inflationCtx);
+  const renderedGroupIds = /* @__PURE__ */ new Set();
+  const groupsToRender = [...sourceGroups];
+  while (groupsToRender.length > 0) {
+    const groupIndex = groupsToRender.findIndex(
+      (g) => !g.parent_source_group_id || renderedGroupIds.has(g.parent_source_group_id)
+    );
+    if (groupIndex === -1) {
+      const remainingIds = groupsToRender.map((g) => g.source_group_id).join(", ");
+      throw new Error(
+        `Cannot inflate source_groups: cyclic dependency or missing parent detected. Remaining groups: ${remainingIds}`
+      );
+    }
+    const groupToRender = groupsToRender[groupIndex];
+    inflateSourceGroup(groupToRender, inflationCtx);
+    renderedGroupIds.add(groupToRender.source_group_id);
+    groupsToRender.splice(groupIndex, 1);
   }
   const pcbBoards = injectionDb.pcb_board.list();
   for (const pcbBoard of pcbBoards) {
@@ -17531,7 +17547,7 @@ import { identity as identity4 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1042",
+  version: "0.0.1043",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -17660,6 +17676,11 @@ var IsolatedCircuit = class {
    * for subcircuit rendering.
    */
   cachedSubcircuits;
+  /**
+   * Map to track pending renders by prop hash. This allows multiple subcircuits
+   * with the same props to wait for a single render instead of each doing their own.
+   */
+  pendingSubcircuitRenders;
   _schematicDisabledOverride;
   get schematicDisabled() {
     if (this._schematicDisabledOverride !== void 0) {
@@ -17696,7 +17717,8 @@ var IsolatedCircuit = class {
   constructor({
     platform,
     projectUrl,
-    cachedSubcircuits
+    cachedSubcircuits,
+    pendingSubcircuitRenders
   } = {}) {
     this.children = [];
     this.db = su5([]);
@@ -17704,6 +17726,7 @@ var IsolatedCircuit = class {
     this.projectUrl = projectUrl;
     this.pcbDisabled = platform?.pcbDisabled ?? false;
     this.cachedSubcircuits = cachedSubcircuits;
+    this.pendingSubcircuitRenders = pendingSubcircuitRenders;
     this.root = this;
   }
   add(componentOrElm) {
@@ -17914,6 +17937,7 @@ function Subcircuit_doInitialRenderIsolatedSubcircuits(subcircuit) {
   if (subcircuit._isolatedCircuitJson) return;
   const propHash = subcircuit.getSubcircuitPropHash();
   const cachedSubcircuits = subcircuit.root?.cachedSubcircuits;
+  const pendingSubcircuitRenders = subcircuit.root?.pendingSubcircuitRenders;
   const cached = cachedSubcircuits?.get(propHash);
   if (cached) {
     subcircuit._isolatedCircuitJson = cached;
@@ -17921,26 +17945,54 @@ function Subcircuit_doInitialRenderIsolatedSubcircuits(subcircuit) {
     subcircuit._normalComponentNameMap = null;
     return;
   }
-  const parentRoot = subcircuit.root;
   const childrenToRender = [...subcircuit.children];
   subcircuit.children = [];
   subcircuit._normalComponentNameMap = null;
+  const parentRoot = subcircuit.root;
   subcircuit._queueAsyncEffect("render-isolated-subcircuit", async () => {
-    const isolatedCircuit = new IsolatedCircuit({
-      platform: {
-        ...parentRoot.platform,
-        pcbDisabled: parentRoot.pcbDisabled,
-        schematicDisabled: parentRoot.schematicDisabled
-      },
-      cachedSubcircuits
-    });
-    for (const child of childrenToRender) {
-      isolatedCircuit.add(child);
+    const cachedResult = cachedSubcircuits?.get(propHash);
+    if (cachedResult) {
+      subcircuit._isolatedCircuitJson = cachedResult;
+      return;
+    }
+    const pendingRenderPromise = pendingSubcircuitRenders?.get(propHash);
+    if (pendingRenderPromise) {
+      subcircuit._isolatedCircuitJson = await pendingRenderPromise;
+      return;
+    }
+    let resolveRender;
+    let rejectRender;
+    const renderPromise = new Promise(
+      (resolve, reject) => {
+        resolveRender = resolve;
+        rejectRender = reject;
+      }
+    );
+    pendingSubcircuitRenders?.set(propHash, renderPromise);
+    try {
+      const isolatedCircuit = new IsolatedCircuit({
+        platform: {
+          ...parentRoot.platform,
+          pcbDisabled: parentRoot.pcbDisabled,
+          schematicDisabled: parentRoot.schematicDisabled
+        },
+        cachedSubcircuits,
+        pendingSubcircuitRenders
+      });
+      for (const child of childrenToRender) {
+        isolatedCircuit.add(child);
+      }
+      await isolatedCircuit.renderUntilSettled();
+      const circuitJson = isolatedCircuit.getCircuitJson();
+      cachedSubcircuits?.set(propHash, circuitJson);
+      subcircuit._isolatedCircuitJson = circuitJson;
+      resolveRender(circuitJson);
+    } catch (error) {
+      rejectRender(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    } finally {
+      pendingSubcircuitRenders?.delete(propHash);
     }
-    await isolatedCircuit.renderUntilSettled();
-    const circuitJson = isolatedCircuit.getCircuitJson();
-    cachedSubcircuits?.set(propHash, circuitJson);
-    subcircuit._isolatedCircuitJson = circuitJson;
   });
 }
 
@@ -17959,6 +18011,32 @@ var EXCLUDED_PROPS = /* @__PURE__ */ new Set([
   "pcbRotation",
   "schRotation"
 ]);
+function safeSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const type = typeof value;
+  if (type === "string") return `"${value}"`;
+  if (type === "number" || type === "boolean") return String(value);
+  if (type === "function") return "[function]";
+  if (type === "symbol") return "[symbol]";
+  if (type === "object") {
+    if (seen.has(value)) return "[circular]";
+    seen.add(value);
+    if (value.$$typeof !== void 0) {
+      const elementType = typeof value.type === "string" ? value.type : value.type?.name || "[component]";
+      const propsStr = value.props ? safeSerialize(value.props, seen) : "{}";
+      return `ReactElement(${elementType},${propsStr})`;
+    }
+    if (Array.isArray(value)) {
+      const items = value.map((v) => safeSerialize(v, seen)).join(",");
+      return `[${items}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const pairs3 = keys.map((k) => `${k}:${safeSerialize(value[k], seen)}`);
+    return `{${pairs3.join(",")}}`;
+  }
+  return String(value);
+}
 function getHashableProps(props) {
   const result = {};
   const keys = Object.keys(props).sort();
@@ -17985,9 +18063,9 @@ function fnv1aHash(str) {
   return hash >>> 0;
 }
 function computeHash(data) {
-  const jsonString = JSON.stringify(data);
-  const hash1 = fnv1aHash(jsonString);
-  const hash2 = fnv1aHash(jsonString + hash1.toString());
+  const serialized = safeSerialize(data);
+  const hash1 = fnv1aHash(serialized);
+  const hash2 = fnv1aHash(serialized + hash1.toString());
   return hash1.toString(16).padStart(8, "0") + hash2.toString(16).padStart(8, "0");
 }
 function Subcircuit_getSubcircuitPropHash(subcircuit) {
@@ -23310,7 +23388,8 @@ var RootCircuit = class extends IsolatedCircuit {
     super({
       platform,
       projectUrl,
-      cachedSubcircuits: /* @__PURE__ */ new Map()
+      cachedSubcircuits: /* @__PURE__ */ new Map(),
+      pendingSubcircuitRenders: /* @__PURE__ */ new Map()
     });
     this.root = this;
   }

package/package.json

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