@tscircuit/checks 0.0.206 → 0.0.208

package/dist/index.js

@@ -714,7 +714,172 @@ import {
   findConnectedNetworks,
   PcbConnectivityMap
 } from "circuit-json-to-connectivity-map";
+import Flatbush3 from "flatbush";
+
+// lib/util/get-via-and-pour-connections.ts
+import { all_layers } from "circuit-json";
+import {
+  getPourPolygon,
+  getTraceSegmentPolygon,
+  getViaPolygon
+} from "@tscircuit/circuit-json-util";
 import Flatbush2 from "flatbush";
+
+// lib/copper-pour-connectivity/create-copper-polygon-contact-tester.ts
+import {
+  Box
+} from "@flatten-js/core";
+function createCopperPolygonContactTester(tolerance) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const getGeometry = (polygon) => {
+    let geometry = cache.get(polygon);
+    if (!geometry) {
+      geometry = {
+        box: polygon.box,
+        facePoints: [...polygon.faces].map((face) => face.first.start),
+        edges: [...polygon.edges].map((edge) => edge.shape),
+        edgeIndex: polygon.edges
+      };
+      cache.set(polygon, geometry);
+    }
+    return geometry;
+  };
+  return (a, b) => {
+    if (a.isEmpty() || b.isEmpty()) return false;
+    const ga = getGeometry(a);
+    const gb = getGeometry(b);
+    if (ga.box.xmin > gb.box.xmax + tolerance || ga.box.xmax < gb.box.xmin - tolerance || ga.box.ymin > gb.box.ymax + tolerance || ga.box.ymax < gb.box.ymin - tolerance)
+      return false;
+    if (ga.facePoints.some(
+      (point2) => gb.box.contains(point2) && b.contains(point2)
+    ) || gb.facePoints.some((point2) => ga.box.contains(point2) && a.contains(point2)))
+      return true;
+    const [small, large] = ga.edges.length <= gb.edges.length ? [ga, gb] : [gb, ga];
+    for (const edge of small.edges) {
+      const box = edge.box;
+      const queryBox = new Box(
+        box.xmin - tolerance,
+        box.ymin - tolerance,
+        box.xmax + tolerance,
+        box.ymax + tolerance
+      );
+      const candidates = large.edgeIndex.search(
+        queryBox
+      );
+      for (const candidate of candidates) {
+        if (edge.distanceTo(candidate.shape)[0] <= tolerance) return true;
+      }
+    }
+    return false;
+  };
+}
+
+// lib/util/get-via-and-pour-connections.ts
+function getViaAndPourConnections(circuit) {
+  if (!circuit.some(
+    (e) => e.type === "pcb_via" || e.type === "pcb_copper_pour" || e.type === "pcb_trace" && e.route.some((p) => p.route_type === "via")
+  ))
+    return [];
+  const conductors = [];
+  const connections = [];
+  const scale = 1e6;
+  const tolerance = 1e-7 * scale;
+  const touches = createCopperPolygonContactTester(tolerance);
+  const add = (id, layers, polygon, bridges = false) => {
+    if (!polygon.isEmpty())
+      conductors.push({
+        id,
+        layers,
+        polygon: polygon.scale(scale, scale),
+        bridges
+      });
+  };
+  const vias = circuit.filter((e) => e.type === "pcb_via");
+  const board = circuit.find((e) => e.type === "pcb_board");
+  const stack = [
+    "top",
+    ...all_layers.filter((l) => l.startsWith("inner")).slice(0, board ? Math.max(0, board.num_layers - 2) : void 0),
+    ...board?.num_layers === 1 ? [] : ["bottom"]
+  ];
+  for (const copper of circuit) {
+    if (copper.type === "pcb_via") {
+      add(
+        copper.pcb_via_id,
+        copper.layers,
+        getViaPolygon(copper, copper.outer_diameter, 0),
+        true
+      );
+      if (copper.pcb_trace_id)
+        connections.push([copper.pcb_via_id, copper.pcb_trace_id]);
+    } else if (copper.type === "pcb_copper_pour") {
+      add(
+        copper.pcb_copper_pour_id,
+        [copper.layer],
+        getPourPolygon(copper),
+        true
+      );
+    } else if (copper.type === "pcb_trace") {
+      if (copper.route_thickness_mode === "interpolated") continue;
+      for (let i = 0; i < copper.route.length; i++) {
+        const a = copper.route[i], b = copper.route[i + 1];
+        if (a.route_type === "wire" && b?.route_type === "wire" && a.layer === b.layer && (a.x !== b.x || a.y !== b.y)) {
+          add(
+            copper.pcb_trace_id,
+            [a.layer],
+            getTraceSegmentPolygon(a, b, a.width)
+          );
+        } else if (a.route_type === "via") {
+          if (vias.some(
+            (v) => v.pcb_trace_id === copper.pcb_trace_id && Math.hypot(v.x - a.x, v.y - a.y) < 1e-9
+          ))
+            continue;
+          const from = stack.indexOf(a.from_layer), to = stack.indexOf(a.to_layer);
+          if (from < 0 || to < 0 || !a.outer_diameter) continue;
+          const via = {
+            type: "pcb_via",
+            pcb_via_id: `${copper.pcb_trace_id}_via_${i}`,
+            x: a.x,
+            y: a.y,
+            outer_diameter: a.outer_diameter,
+            hole_diameter: 0,
+            layers: stack.slice(Math.min(from, to), Math.max(from, to) + 1)
+          };
+          add(
+            copper.pcb_trace_id,
+            via.layers,
+            getViaPolygon(via, via.outer_diameter, 0),
+            true
+          );
+        }
+      }
+    }
+  }
+  if (!conductors.length) return connections;
+  const index = new Flatbush2(conductors.length);
+  for (const { polygon } of conductors) {
+    const b = polygon.box;
+    index.add(b.xmin, b.ymin, b.xmax, b.ymax);
+  }
+  index.finish();
+  for (const [i, a] of conductors.entries()) {
+    if (!a.bridges) continue;
+    const box = a.polygon.box;
+    for (const j of index.search(
+      box.xmin - tolerance,
+      box.ymin - tolerance,
+      box.xmax + tolerance,
+      box.ymax + tolerance
+    )) {
+      const b = conductors[j];
+      if (i === j || a.id === b.id || b.bridges && j < i || !a.layers.some((l) => b.layers.includes(l)))
+        continue;
+      if (touches(a.polygon, b.polygon)) connections.push([a.id, b.id]);
+    }
+  }
+  return connections;
+}
+
+// lib/util/create-indexed-pcb-connectivity-map.ts
 function createIndexedPcbConnectivityMap(circuitJson) {
   const map = new PcbConnectivityMap();
   map.circuitJson = circuitJson;
@@ -756,7 +921,7 @@ function createIndexedPcbConnectivityMap(circuitJson) {
   }
   const candidates = traces.map(() => /* @__PURE__ */ new Set());
   for (const bounds of boundsByLayer.values()) {
-    const index = new Flatbush2(bounds.length);
+    const index = new Flatbush3(bounds.length);
     for (const box of bounds) index.add(box.minX, box.minY, box.maxX, box.maxY);
     index.finish();
     for (const box of bounds) {
@@ -795,6 +960,7 @@ function createIndexedPcbConnectivityMap(circuitJson) {
     for (const connection of connectionsByPort.get(portId) ?? [])
       connections.push(connection);
   }
+  connections.push(...getViaAndPourConnections(circuitJson));
   map.connMap = new ConnectivityMap(findConnectedNetworks(connections));
   return map;
 }
@@ -1267,16 +1433,16 @@ function getReadableNameForFootprintPad(circuitJson, pad, ordinal) {
 // lib/copper-pour-connectivity/get-copper-pour-connectivity.ts
 import {
   getPrimaryId,
-  copperPolygonsTouch,
   getPlatedHolePolygon,
-  getPourPolygon,
+  getPourPolygon as getPourPolygon2,
   getSmtPadPolygon,
-  getTraceSegmentPolygon,
-  getViaPolygon
+  getTraceSegmentPolygon as getTraceSegmentPolygon2,
+  getViaPolygon as getViaPolygon2
 } from "@tscircuit/circuit-json-util";
 function getCopperPourConnectivity(circuitJson, connectivity) {
   const scale = 1e6;
   const tolerance = 1e-7 * scale;
+  const copperPolygonsTouch = createCopperPolygonContactTester(tolerance);
   const conductors = [];
   const pouredNets = /* @__PURE__ */ new Set();
   const netForId = (id) => connectivity.getNetConnectedToId(id);
@@ -1294,7 +1460,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
     if (!netId) continue;
     pouredNets.add(netId);
     add({
-      polygon: getPourPolygon(pour),
+      polygon: getPourPolygon2(pour),
       layers: [pour.layer],
       netId,
       isPour: true
@@ -1315,7 +1481,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
           if (start.route_type !== "wire" || end.route_type !== "wire" || start.layer !== end.layer)
             continue;
           add({
-            polygon: getTraceSegmentPolygon(start, end, start.width),
+            polygon: getTraceSegmentPolygon2(start, end, start.width),
             layers: [start.layer],
             netId: netId2
           });
@@ -1345,7 +1511,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
         });
       } else {
         add({
-          polygon: getViaPolygon(
+          polygon: getViaPolygon2(
             copper,
             copper.outer_diameter,
             copper.hole_diameter
@@ -1380,11 +1546,7 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
         (layer) => conductors[j].layers.includes(layer)
       ))
         continue;
-      if (copperPolygonsTouch(
-        conductors[i].polygon,
-        conductors[j].polygon,
-        tolerance
-      ))
+      if (copperPolygonsTouch(conductors[i].polygon, conductors[j].polygon))
         parent[find(j)] = find(i);
     }
   }
@@ -2000,7 +2162,7 @@ var SpatialObjectIndex = class {
 };
 
 // lib/util/getLayersOfPcbElement.ts
-import { all_layers } from "circuit-json";
+import { all_layers as all_layers2 } from "circuit-json";
 function getLayersOfPcbElement(obj) {
   if (obj.type === "pcb_trace_segment") {
     return [obj.layer];
@@ -2009,13 +2171,13 @@ function getLayersOfPcbElement(obj) {
     return [obj.layer];
   }
   if (obj.type === "pcb_plated_hole") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers2];
   }
   if (obj.type === "pcb_hole") {
-    return [...all_layers];
+    return [...all_layers2];
   }
   if (obj.type === "pcb_via") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers2];
   }
   if (obj.type === "pcb_keepout") {
     return Array.isArray(obj.layers) ? obj.layers : [];
@@ -3444,7 +3606,7 @@ import {
 
 // lib/check-traces-are-contiguous/via-contact-index.ts
 import {
-  all_layers as all_layers2
+  all_layers as all_layers3
 } from "circuit-json";
 import { getPrimaryId as getPrimaryId4 } from "@tscircuit/circuit-json-util";
 import { pointToSegmentDistance as pointToSegmentDistance2 } from "@tscircuit/math-utils";
@@ -3456,7 +3618,7 @@ function getViaContactIndex(circuitJson, connectivity) {
   const vias = circuitJson.filter((element) => element.type === "pcb_via");
   const board = circuitJson.find((element) => element.type === "pcb_board");
   const layerCount = board?.num_layers;
-  const innerLayers = all_layers2.filter((layer) => layer.startsWith("inner"));
+  const innerLayers = all_layers3.filter((layer) => layer.startsWith("inner"));
   const stack = [
     "top",
     ...innerLayers.slice(