@tscircuit/core 0.0.2152 → 0.0.2153

package/dist/index.js

@@ -7179,50 +7179,248 @@ function getSavedTraceViaContactWidths(route, viaIndex, fallbackWidth) {
   };
 }
 
-// lib/components/primitive-components/Trace/Trace_doInitialPcbTraceTeardropRender.ts
-var generatedRoutes = /* @__PURE__ */ new WeakMap();
-function hasSameGeneratedGeometry(current, generated) {
-  if (current === generated) return true;
-  if (current.length !== generated.length) return false;
-  const geometry = (point6) => {
-    const { is_inside_copper_pour, copper_pour_id, ...rest } = point6;
-    return JSON.stringify(rest);
-  };
-  return current.every(
-    (point6, index2) => geometry(point6) === geometry(generated[index2])
+// lib/components/primitive-components/Trace/update-pcb-trace-teardrop-contacts.ts
+var pcbTraceTeardropRenderStateByRoot = /* @__PURE__ */ new WeakMap();
+function getRoutePointGeometryJson(routePoint) {
+  const { is_inside_copper_pour, copper_pour_id, ...rest } = routePoint;
+  return JSON.stringify(rest);
+}
+function hasSameGeneratedGeometry(currentRoute, generatedRoute) {
+  if (currentRoute === generatedRoute) return true;
+  if (currentRoute.length !== generatedRoute.length) return false;
+  return currentRoute.every(
+    (routePoint, routePointIndex) => getRoutePointGeometryJson(routePoint) === getRoutePointGeometryJson(generatedRoute[routePointIndex])
+  );
+}
+function getPcbTraceTeardropRenderStateByPcbTraceId(root) {
+  const existingState = pcbTraceTeardropRenderStateByRoot.get(root);
+  if (existingState) return existingState;
+  const createdState = /* @__PURE__ */ new Map();
+  pcbTraceTeardropRenderStateByRoot.set(root, createdState);
+  return createdState;
+}
+function refreshPcbTraceTeardropBaseline({
+  pcbTrace,
+  pcbTraceTeardropRenderState
+}) {
+  if (hasSameGeneratedGeometry(
+    pcbTrace.route,
+    pcbTraceTeardropRenderState.generatedRoute
+  )) {
+    return false;
+  }
+  pcbTraceTeardropRenderState.originalRoute = pcbTrace.route;
+  pcbTraceTeardropRenderState.generatedRoute = pcbTrace.route;
+  return true;
+}
+function getRouteWithExplicitViaContacts({
+  route,
+  contacts
+}) {
+  return route.flatMap((routePoint, routePointIndex) => {
+    if (routePoint.route_type !== "via" || !contacts.some(
+      (contact) => Math.hypot(contact.x - routePoint.x, contact.y - routePoint.y) < 1e-6
+    )) {
+      return [routePoint];
+    }
+    const { fromWidth, toWidth } = getSavedTraceViaContactWidths(
+      route,
+      routePointIndex,
+      0
+    );
+    if (!fromWidth || !toWidth) return [routePoint];
+    const previousRoutePoint = route[routePointIndex - 1];
+    const nextRoutePoint = route[routePointIndex + 1];
+    const explicitViaContactRoute = [];
+    if (!(previousRoutePoint?.route_type === "wire" && previousRoutePoint.x === routePoint.x && previousRoutePoint.y === routePoint.y && previousRoutePoint.layer === routePoint.from_layer)) {
+      explicitViaContactRoute.push({
+        route_type: "wire",
+        x: routePoint.x,
+        y: routePoint.y,
+        width: fromWidth,
+        layer: routePoint.from_layer
+      });
+    }
+    explicitViaContactRoute.push(routePoint);
+    if (!(nextRoutePoint?.route_type === "wire" && nextRoutePoint.x === routePoint.x && nextRoutePoint.y === routePoint.y && nextRoutePoint.layer === routePoint.to_layer)) {
+      explicitViaContactRoute.push({
+        route_type: "wire",
+        x: routePoint.x,
+        y: routePoint.y,
+        width: toWidth,
+        layer: routePoint.to_layer
+      });
+    }
+    return explicitViaContactRoute;
+  });
+}
+function renderPcbTraceTeardrops({
+  root,
+  pcbTraceId,
+  pcbTraceTeardropRenderStateByPcbTraceId
+}) {
+  const pcbTraceTeardropRenderState = pcbTraceTeardropRenderStateByPcbTraceId.get(pcbTraceId);
+  if (!pcbTraceTeardropRenderState) return;
+  const pcbTrace = root.db.pcb_trace.get(pcbTraceId);
+  if (!pcbTrace) {
+    pcbTraceTeardropRenderStateByPcbTraceId.delete(pcbTraceId);
+    return;
+  }
+  refreshPcbTraceTeardropBaseline({
+    pcbTrace,
+    pcbTraceTeardropRenderState
+  });
+  const contacts = [
+    ...pcbTraceTeardropRenderState.contactsBySourceTraceId.values()
+  ].flat();
+  const routeWithExplicitViaContacts = getRouteWithExplicitViaContacts({
+    route: pcbTraceTeardropRenderState.originalRoute,
+    contacts
+  });
+  const generatedRoute = addTraceTeardrops(
+    routeWithExplicitViaContacts,
+    contacts
   );
+  root.db.pcb_trace.update(pcbTraceId, { route: generatedRoute });
+  if (contacts.length === 0) {
+    pcbTraceTeardropRenderStateByPcbTraceId.delete(pcbTraceId);
+    return;
+  }
+  pcbTraceTeardropRenderState.generatedRoute = generatedRoute;
 }
+function updatePcbTraceTeardropContacts({
+  root,
+  sourceTraceId,
+  contactsByPcbTraceId
+}) {
+  const pcbTraceTeardropRenderStateByPcbTraceId = getPcbTraceTeardropRenderStateByPcbTraceId(root);
+  const affectedPcbTraceIds = /* @__PURE__ */ new Set();
+  for (const [
+    pcbTraceId,
+    pcbTraceTeardropRenderState
+  ] of pcbTraceTeardropRenderStateByPcbTraceId) {
+    const pcbTrace = root.db.pcb_trace.get(pcbTraceId);
+    if (!pcbTrace) {
+      pcbTraceTeardropRenderStateByPcbTraceId.delete(pcbTraceId);
+      continue;
+    }
+    if (refreshPcbTraceTeardropBaseline({
+      pcbTrace,
+      pcbTraceTeardropRenderState
+    })) {
+      affectedPcbTraceIds.add(pcbTraceId);
+    }
+    if (pcbTraceTeardropRenderState.contactsBySourceTraceId.delete(sourceTraceId)) {
+      affectedPcbTraceIds.add(pcbTraceId);
+    }
+  }
+  for (const [pcbTraceId, contacts] of contactsByPcbTraceId) {
+    const pcbTrace = root.db.pcb_trace.get(pcbTraceId);
+    if (!pcbTrace || contacts.length === 0) continue;
+    let pcbTraceTeardropRenderState = pcbTraceTeardropRenderStateByPcbTraceId.get(pcbTraceId);
+    if (!pcbTraceTeardropRenderState) {
+      pcbTraceTeardropRenderState = {
+        originalRoute: pcbTrace.route,
+        generatedRoute: pcbTrace.route,
+        contactsBySourceTraceId: /* @__PURE__ */ new Map()
+      };
+      pcbTraceTeardropRenderStateByPcbTraceId.set(
+        pcbTraceId,
+        pcbTraceTeardropRenderState
+      );
+    } else {
+      refreshPcbTraceTeardropBaseline({
+        pcbTrace,
+        pcbTraceTeardropRenderState
+      });
+    }
+    pcbTraceTeardropRenderState.contactsBySourceTraceId.set(
+      sourceTraceId,
+      contacts
+    );
+    affectedPcbTraceIds.add(pcbTraceId);
+  }
+  for (const pcbTraceId of affectedPcbTraceIds) {
+    renderPcbTraceTeardrops({
+      root,
+      pcbTraceId,
+      pcbTraceTeardropRenderStateByPcbTraceId
+    });
+  }
+}
+
+// lib/components/primitive-components/Trace/Trace_doInitialPcbTraceTeardropRender.ts
 function getPadDiameter(pad) {
   if (pad.shape === "polygon") return 0;
   if (pad.shape === "circle") return pad.radius * 2;
   return Math.min(pad.width, pad.height);
 }
-function Trace_doInitialPcbTraceTeardropRender(trace) {
-  if (!trace.root || trace.root.pcbDisabled || !trace.source_trace_id) return;
-  const { db: db2 } = trace.root;
-  const props = trace._parsedProps;
-  const previous = generatedRoutes.get(trace);
-  for (const [id, routes] of previous ?? []) {
-    const current = db2.pcb_trace.get(id);
-    if (current && hasSameGeneratedGeometry(current.route, routes.generated))
-      db2.pcb_trace.update(id, { route: routes.original });
-  }
-  generatedRoutes.delete(trace);
-  if (!props.pcbTeardrops && !props.pcbTeardropStart && !props.pcbTeardropEnd)
-    return;
-  const connected = trace._findConnectedPorts();
-  if (!connected.allPortsFound) return;
-  const selectors = trace._getTracePortOrNetSelectorListFromProps();
-  const enabledPorts = connected.portsWithSelectors.map(
-    ({ port, selector }) => ({
-      port,
-      enabled: selector === selectors[0] ? props.pcbTeardropStart ?? props.pcbTeardrops ?? false : selector === selectors.at(-1) ? props.pcbTeardropEnd ?? props.pcbTeardrops ?? false : props.pcbTeardrops ?? false
-    })
-  );
+function getConnectedPcbTraces({
+  root,
+  sourceTraceId
+}) {
+  const sourceTrace = root.db.source_trace.get(sourceTraceId);
+  const connectivityMapKey = sourceTrace?.subcircuit_connectivity_map_key;
+  if (!connectivityMapKey) {
+    return root.db.pcb_trace.list({ source_trace_id: sourceTraceId });
+  }
+  return root.db.pcb_trace.list().filter((pcbTrace) => {
+    if (pcbTrace.source_trace_id === sourceTraceId) return true;
+    if (!pcbTrace.source_trace_id) return false;
+    const routedSourceTrace = root.db.source_trace.get(pcbTrace.source_trace_id);
+    return routedSourceTrace?.subcircuit_connectivity_map_key === connectivityMapKey;
+  });
+}
+function getTeardropContacts({
+  root,
+  pcbTrace,
+  enabledPorts,
+  padContacts,
+  enableUnmatchedVias
+}) {
+  const contacts = [...padContacts];
+  for (const via of root.db.pcb_via.list({
+    pcb_trace_id: pcbTrace.pcb_trace_id
+  })) {
+    const endpoint = enabledPorts.find(({ port }) => {
+      const position = port._getGlobalPcbPositionAfterLayout();
+      return Math.hypot(position.x - via.x, position.y - via.y) < 1e-6;
+    });
+    if (!(endpoint ? endpoint.enabled : enableUnmatchedVias)) continue;
+    for (const layer of via.layers) {
+      contacts.push({
+        x: via.x,
+        y: via.y,
+        layer,
+        diameter: via.outer_diameter
+      });
+    }
+  }
+  return contacts;
+}
+function isTeardropEnabledForSelector({
+  selector,
+  selectors,
+  props
+}) {
+  if (selector === selectors[0]) {
+    return props.pcbTeardropStart ?? props.pcbTeardrops ?? false;
+  }
+  if (selector === selectors.at(-1)) {
+    return props.pcbTeardropEnd ?? props.pcbTeardrops ?? false;
+  }
+  return props.pcbTeardrops ?? false;
+}
+function getPadContacts({
+  root,
+  enabledPorts
+}) {
   const padContacts = [];
   for (const { port, enabled } of enabledPorts) {
     if (!enabled || !port.pcb_port_id) continue;
-    for (const pad of db2.pcb_smtpad.list({ pcb_port_id: port.pcb_port_id })) {
+    for (const pad of root.db.pcb_smtpad.list({
+      pcb_port_id: port.pcb_port_id
+    })) {
       if (pad.shape === "polygon") continue;
       padContacts.push({
         x: pad.x,
@@ -7231,84 +7429,66 @@ function Trace_doInitialPcbTraceTeardropRender(trace) {
         diameter: getPadDiameter(pad)
       });
     }
-    for (const hole of db2.pcb_plated_hole.list({
+    for (const hole of root.db.pcb_plated_hole.list({
       pcb_port_id: port.pcb_port_id
     })) {
       if (hole.shape !== "circle") continue;
-      for (const layer of hole.layers)
+      for (const layer of hole.layers) {
         padContacts.push({
           x: hole.x,
           y: hole.y,
           layer,
           diameter: hole.outer_diameter
         });
+      }
     }
   }
-  const outputs = /* @__PURE__ */ new Map();
-  for (const pcbTrace of db2.pcb_trace.list({
-    source_trace_id: trace.source_trace_id
-  })) {
-    const contacts = [...padContacts];
-    for (const via of db2.pcb_via.list({
-      pcb_trace_id: pcbTrace.pcb_trace_id
+  return padContacts;
+}
+function Trace_doInitialPcbTraceTeardropRender(trace) {
+  if (!trace.root || trace.root.pcbDisabled || !trace.source_trace_id) return;
+  const root = trace.root;
+  const sourceTraceId = trace.source_trace_id;
+  const props = trace._parsedProps;
+  const contactsByPcbTraceId = /* @__PURE__ */ new Map();
+  const anyTeardropsEnabled = Boolean(
+    props.pcbTeardrops || props.pcbTeardropStart || props.pcbTeardropEnd
+  );
+  const connected = anyTeardropsEnabled ? trace._findConnectedPorts() : void 0;
+  if (connected?.allPortsFound) {
+    const selectors = trace._getTracePortOrNetSelectorListFromProps();
+    const enabledPorts = connected.portsWithSelectors.map(
+      ({ port, selector }) => ({
+        port,
+        enabled: isTeardropEnabledForSelector({
+          selector,
+          selectors,
+          props
+        })
+      })
+    );
+    const padContacts = getPadContacts({ root, enabledPorts });
+    for (const pcbTrace of getConnectedPcbTraces({
+      root,
+      sourceTraceId
     })) {
-      const endpoint = enabledPorts.find(({ port }) => {
-        const position = port._getGlobalPcbPositionAfterLayout();
-        return Math.hypot(position.x - via.x, position.y - via.y) < 1e-6;
-      });
-      if (!(endpoint ? endpoint.enabled : props.pcbTeardrops)) continue;
-      for (const layer of via.layers)
-        contacts.push({
-          x: via.x,
-          y: via.y,
-          layer,
-          diameter: via.outer_diameter
-        });
+      contactsByPcbTraceId.set(
+        pcbTrace.pcb_trace_id,
+        getTeardropContacts({
+          root,
+          pcbTrace,
+          enabledPorts,
+          padContacts,
+          enableUnmatchedVias: props.pcbTeardrops ?? false
+        })
+      );
     }
-    const wireContacts = pcbTrace.route.flatMap(
-      (point6, index2) => {
-        if (point6.route_type !== "via" || !contacts.some(
-          (contact) => Math.hypot(contact.x - point6.x, contact.y - point6.y) < 1e-6
-        ))
-          return [point6];
-        const { fromWidth, toWidth } = getSavedTraceViaContactWidths(
-          pcbTrace.route,
-          index2,
-          0
-        );
-        if (!fromWidth || !toWidth) return [point6];
-        const before = pcbTrace.route[index2 - 1];
-        const after = pcbTrace.route[index2 + 1];
-        const result = [];
-        if (!(before?.route_type === "wire" && before.x === point6.x && before.y === point6.y && before.layer === point6.from_layer))
-          result.push({
-            route_type: "wire",
-            x: point6.x,
-            y: point6.y,
-            width: fromWidth,
-            layer: point6.from_layer
-          });
-        result.push(point6);
-        if (!(after?.route_type === "wire" && after.x === point6.x && after.y === point6.y && after.layer === point6.to_layer))
-          result.push({
-            route_type: "wire",
-            x: point6.x,
-            y: point6.y,
-            width: toWidth,
-            layer: point6.to_layer
-          });
-        return result;
-      }
-    );
-    const route = addTraceTeardrops(wireContacts, contacts);
-    if (route.length === pcbTrace.route.length) continue;
-    outputs.set(pcbTrace.pcb_trace_id, {
-      original: pcbTrace.route,
-      generated: route
-    });
-    db2.pcb_trace.update(pcbTrace.pcb_trace_id, { route });
   }
-  generatedRoutes.set(trace, outputs);
+  updatePcbTraceTeardropContacts({
+    root,
+    sourceTraceId,
+    contactsByPcbTraceId
+  });
 }
 
 // lib/components/primitive-components/Trace/Trace_doInitialPcbTraceRender.ts
@@ -118982,7 +119162,7 @@ var RoutingPhasePreparationError = class extends Error {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2151",
+  version: "0.0.2152",
   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.2152",
+  "version": "0.0.2153",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",