@tscircuit/checks 0.0.205 → 0.0.207

package/dist/index.d.ts

@@ -1,11 +1,16 @@
 import * as circuit_json from 'circuit-json';
 import { AnyCircuitElement, PcbPlacementError, PcbPortNotConnectedError, PcbTraceError, PcbKeepoutOverlapWarning, PcbComponentOutsideBoardError, PcbViaClearanceError, PcbTraceWarning, PcbTraceMissingError, PcbFootprintOverlapError, PcbPadPadClearanceError, PcbCourtyardOverlapError, PcbComponentMissingCourtyardWarning, PcbTraceTooLongError, PcbPadTraceClearanceError, PcbViaTraceClearanceError, SourceComponentMisconfiguredError, SourceComponentPinsUnderspecifiedWarning, SourceNoPowerPinDefinedWarning, SourceNoGroundPinDefinedWarning, SchematicComponentStylingWarning, PcbConnectorNotInAccessibleOrientationWarning, SourceConfusingNetNameWarning, PcbBusLengthSkewError } from 'circuit-json';
-import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
+import { ConnectivityMap, PcbConnectivityMap } from 'circuit-json-to-connectivity-map';
 
 /** Detect accidental copper contact, rather than enforcing a clearance margin. */
-declare function checkCopperPourShorts(circuitJson: AnyCircuitElement[]): PcbPlacementError[];
+declare function checkCopperPourShorts(circuitJson: AnyCircuitElement[], { connMap }?: {
+    connMap?: ConnectivityMap;
+}): PcbPlacementError[];
 
-declare function checkEachPcbPortConnectedToPcbTraces(circuitJson: AnyCircuitElement[]): PcbPortNotConnectedError[];
+declare function checkEachPcbPortConnectedToPcbTraces(circuitJson: AnyCircuitElement[], { connMap, pcbConnectivityMap, }?: {
+    connMap?: ConnectivityMap;
+    pcbConnectivityMap?: PcbConnectivityMap;
+}): PcbPortNotConnectedError[];
 
 declare function checkEachPcbTraceNonOverlapping(circuitJson: AnyCircuitElement[], { connMap, minClearance, }?: {
     connMap?: ConnectivityMap;
@@ -63,9 +68,14 @@ declare function checkSourceTracesMatchPcbTraceThickness(circuitJson: AnyCircuit
  * pcb_trace associated with it, or its ports physically joined through a
  * same-net copper pour. Otherwise return an error for that source_trace.
  */
-declare function checkSourceTracesHavePcbTraces(circuitJson: AnyCircuitElement[]): PcbTraceMissingError[];
+declare function checkSourceTracesHavePcbTraces(circuitJson: AnyCircuitElement[], { connMap }?: {
+    connMap?: ConnectivityMap;
+}): PcbTraceMissingError[];
 
-declare function checkTracesAreContiguous(circuitJson: AnyCircuitElement[]): PcbTraceError[];
+declare function checkTracesAreContiguous(circuitJson: AnyCircuitElement[], { connMap, pcbConnectivityMap, }?: {
+    connMap?: ConnectivityMap;
+    pcbConnectivityMap?: PcbConnectivityMap;
+}): PcbTraceError[];
 
 /**
  * Configuration for trace board boundary checking

package/dist/index.js

@@ -635,14 +635,16 @@ function convertCircuitJsonToFlattenJs(json, options = {}) {
 }
 
 // lib/check-copper-pour-shorts.ts
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import {
+  getFullConnectivityMapFromCircuitJson
+} from "circuit-json-to-connectivity-map";
 function touchesPour(pour, geometry) {
   if (!pour.box.intersect(geometry.box)) return false;
   return pour.intersect(geometry).length > 0 || [...geometry.faces].some((face) => pour.contains(face.first.start)) || [...pour.faces].some((face) => geometry.contains(face.first.start));
 }
-function checkCopperPourShorts(circuitJson) {
+function checkCopperPourShorts(circuitJson, { connMap } = {}) {
   if (!circuitJson.some((e) => e.type === "pcb_copper_pour")) return [];
-  const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson(circuitJson);
   const { elements: copper } = convertCircuitJsonToFlattenJs(circuitJson, {
     elementTypes: [
       "pcb_smtpad",
@@ -706,6 +708,97 @@ function checkCopperPourShorts(circuitJson) {
   return [...errors.values()];
 }
 
+// lib/util/create-indexed-pcb-connectivity-map.ts
+import {
+  ConnectivityMap,
+  findConnectedNetworks,
+  PcbConnectivityMap
+} from "circuit-json-to-connectivity-map";
+import Flatbush2 from "flatbush";
+function createIndexedPcbConnectivityMap(circuitJson) {
+  const map = new PcbConnectivityMap();
+  map.circuitJson = circuitJson;
+  for (const element of circuitJson) {
+    if (element.type === "pcb_trace") {
+      map.traceIdToElm.set(element.pcb_trace_id, element);
+    } else if (element.type === "pcb_port") {
+      map.portIdToElm.set(element.pcb_port_id, element);
+    }
+  }
+  const traces = [...map.traceIdToElm.values()];
+  const boundsByLayer = /* @__PURE__ */ new Map();
+  for (const [traceIndex, trace] of traces.entries()) {
+    const boundsForTrace = /* @__PURE__ */ new Map();
+    for (let i = 0; i < trace.route.length - 1; i++) {
+      const a = trace.route[i];
+      const b = trace.route[i + 1];
+      if (a.route_type !== "wire" || b.route_type !== "wire" || a.layer !== b.layer)
+        continue;
+      const bounds = boundsForTrace.get(a.layer) ?? {
+        traceIndex,
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+      };
+      const radius = a.width / 2 + 1e-9;
+      bounds.minX = Math.min(bounds.minX, a.x - radius, b.x - radius);
+      bounds.minY = Math.min(bounds.minY, a.y - radius, b.y - radius);
+      bounds.maxX = Math.max(bounds.maxX, a.x + radius, b.x + radius);
+      bounds.maxY = Math.max(bounds.maxY, a.y + radius, b.y + radius);
+      boundsForTrace.set(a.layer, bounds);
+    }
+    for (const [layer, bounds] of boundsForTrace) {
+      const entries = boundsByLayer.get(layer) ?? [];
+      entries.push(bounds);
+      boundsByLayer.set(layer, entries);
+    }
+  }
+  const candidates = traces.map(() => /* @__PURE__ */ new Set());
+  for (const bounds of boundsByLayer.values()) {
+    const index = new Flatbush2(bounds.length);
+    for (const box of bounds) index.add(box.minX, box.minY, box.maxX, box.maxY);
+    index.finish();
+    for (const box of bounds) {
+      for (const hit of index.search(box.minX, box.minY, box.maxX, box.maxY)) {
+        const other = bounds[hit].traceIndex;
+        if (other > box.traceIndex) candidates[box.traceIndex].add(other);
+      }
+    }
+  }
+  const connections = [];
+  for (const [i, neighbors] of candidates.entries()) {
+    for (const j of [...neighbors].sort((a, b) => a - b)) {
+      if (map._arePcbTracesConnected(traces[i], traces[j])) {
+        connections.push([traces[i].pcb_trace_id, traces[j].pcb_trace_id]);
+      }
+    }
+  }
+  const connectionsByPort = /* @__PURE__ */ new Map();
+  for (const trace of traces) {
+    for (const point2 of trace.route) {
+      if (point2.route_type !== "wire") continue;
+      for (const portId of /* @__PURE__ */ new Set([
+        point2.start_pcb_port_id,
+        point2.end_pcb_port_id
+      ])) {
+        if (!portId || !map.portIdToElm.has(portId)) continue;
+        const entries = connectionsByPort.get(portId) ?? [];
+        entries.push(
+          point2.start_pcb_port_id === portId ? [portId, trace.pcb_trace_id] : [trace.pcb_trace_id, portId]
+        );
+        connectionsByPort.set(portId, entries);
+      }
+    }
+  }
+  for (const portId of map.portIdToElm.keys()) {
+    for (const connection of connectionsByPort.get(portId) ?? [])
+      connections.push(connection);
+  }
+  map.connMap = new ConnectivityMap(findConnectedNetworks(connections));
+  return map;
+}
+
 // lib/check-traces-are-contiguous/is-point-in-pad.ts
 import { pointToSegmentDistance } from "@tscircuit/math-utils";
 
@@ -1041,8 +1134,7 @@ var addStartAndEndPortIdsIfMissing = (soup) => {
 
 // lib/check-each-pcb-port-connected-to-pcb-trace.ts
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2,
-  PcbConnectivityMap
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
 } from "circuit-json-to-connectivity-map";
 
 // lib/util/get-readable-names.ts
@@ -1172,10 +1264,58 @@ function getReadableNameForFootprintPad(circuitJson, pad, ordinal) {
   return `${padKind} #${ordinal + 1} at ${location}`;
 }
 
+// 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/copper-pour-connectivity/get-copper-pour-connectivity.ts
 import {
   getPrimaryId,
-  copperPolygonsTouch,
   getPlatedHolePolygon,
   getPourPolygon,
   getSmtPadPolygon,
@@ -1185,6 +1325,7 @@ import {
 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);
@@ -1288,11 +1429,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);
     }
   }
@@ -1339,7 +1476,10 @@ function getCopperPourConnectivity(circuitJson, connectivity) {
 }
 
 // lib/check-each-pcb-port-connected-to-pcb-trace.ts
-function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
+function checkEachPcbPortConnectedToPcbTraces(circuitJson, {
+  connMap,
+  pcbConnectivityMap
+} = {}) {
   addStartAndEndPortIdsIfMissing(circuitJson);
   const sourceTraces = circuitJson.filter(
     (item) => item.type === "source_trace"
@@ -1351,8 +1491,8 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
     (item) => item.type === "source_net"
   );
   const errors = [];
-  const connectivityMap = getFullConnectivityMapFromCircuitJson2(circuitJson);
-  const pcbConnectivityMap = new PcbConnectivityMap(circuitJson);
+  const connectivityMap = connMap ?? getFullConnectivityMapFromCircuitJson2(circuitJson);
+  pcbConnectivityMap ??= createIndexedPcbConnectivityMap(circuitJson);
   let pourConnectivity;
   const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
     circuitJson,
@@ -3279,8 +3419,10 @@ function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
 }
 
 // lib/check-source-traces-have-pcb-traces.ts
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7 } from "circuit-json-to-connectivity-map";
-function checkSourceTracesHavePcbTraces(circuitJson) {
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7
+} from "circuit-json-to-connectivity-map";
+function checkSourceTracesHavePcbTraces(circuitJson, { connMap } = {}) {
   const errors = [];
   const sourceTraces = circuitJson.filter(
     (el) => el.type === "source_trace"
@@ -3294,7 +3436,7 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
   const sourcePortToPcbPort = new Map(
     pcbPorts.map((pcbPort) => [pcbPort.source_port_id, pcbPort])
   );
-  const connectivityMap = getFullConnectivityMapFromCircuitJson7(circuitJson);
+  const connectivityMap = connMap ?? getFullConnectivityMapFromCircuitJson7(circuitJson);
   let pourConnectivity;
   const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
     circuitJson,
@@ -3342,8 +3484,7 @@ import {
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8,
-  PcbConnectivityMap as PcbConnectivityMap2
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8
 } from "circuit-json-to-connectivity-map";
 
 // lib/check-traces-are-contiguous/via-contact-index.ts
@@ -3607,7 +3748,10 @@ function getMissingConnectionErrorCenter({
     y: (firstPointCenter.y + lastPointCenter.y) / 2
   };
 }
-function checkTracesAreContiguous(circuitJson) {
+function checkTracesAreContiguous(circuitJson, {
+  connMap,
+  pcbConnectivityMap
+} = {}) {
   const errors = [];
   const pcbPorts = circuitJson.filter(
     (el) => el.type === "pcb_port"
@@ -3625,8 +3769,8 @@ function checkTracesAreContiguous(circuitJson) {
     (el) => el.type === "pcb_plated_hole"
   );
   const padMap = /* @__PURE__ */ new Map();
-  const pcbConnectivityMap = new PcbConnectivityMap2(circuitJson);
-  let fullConnectivityMap;
+  pcbConnectivityMap ??= createIndexedPcbConnectivityMap(circuitJson);
+  let fullConnectivityMap = connMap;
   let traceWireSegmentsByNetAndLayer;
   const getFullConnectivityMap = () => {
     fullConnectivityMap ??= getFullConnectivityMapFromCircuitJson8(circuitJson);
@@ -5206,6 +5350,9 @@ function checkSchematicComponentPortsOutsideBody(circuitJson) {
   return warnings;
 }
 
+// lib/run-all-checks.ts
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson15 } from "circuit-json-to-connectivity-map";
+
 // lib/check-pcb-bus-length-skew.ts
 var checkPcbBusLengthSkew = (circuitJson) => {
   const buses = circuitJson.filter(
@@ -5731,20 +5878,25 @@ async function runAllPinSpecificationChecks(circuitJson) {
   ];
 }
 async function runAllRoutingChecks(circuitJson) {
+  addStartAndEndPortIdsIfMissing(circuitJson);
+  const connectivity = {
+    connMap: getFullConnectivityMapFromCircuitJson15(circuitJson),
+    pcbConnectivityMap: createIndexedPcbConnectivityMap(circuitJson)
+  };
   return [
-    ...checkEachPcbPortConnectedToPcbTraces(circuitJson),
-    ...checkSourceTracesHavePcbTraces(circuitJson),
+    ...checkEachPcbPortConnectedToPcbTraces(circuitJson, connectivity),
+    ...checkSourceTracesHavePcbTraces(circuitJson, connectivity),
     ...checkPcbTraceLengths(circuitJson),
     ...checkPcbBusLengthSkew(circuitJson),
     ...checkPcbTraceViaCounts(circuitJson),
-    ...checkEachPcbTraceNonOverlapping(circuitJson),
-    ...checkCopperPourShorts(circuitJson),
-    ...checkPadTraceClearance(circuitJson),
-    ...checkViaTraceClearance(circuitJson),
-    ...checkViaPadClearance(circuitJson),
-    ...checkSameNetViaSpacing(circuitJson),
-    ...checkDifferentNetViaSpacing(circuitJson),
-    ...checkTracesAreContiguous(circuitJson),
+    ...checkEachPcbTraceNonOverlapping(circuitJson, connectivity),
+    ...checkCopperPourShorts(circuitJson, connectivity),
+    ...checkPadTraceClearance(circuitJson, connectivity),
+    ...checkViaTraceClearance(circuitJson, connectivity),
+    ...checkViaPadClearance(circuitJson, connectivity),
+    ...checkSameNetViaSpacing(circuitJson, connectivity),
+    ...checkDifferentNetViaSpacing(circuitJson, connectivity),
+    ...checkTracesAreContiguous(circuitJson, connectivity),
     ...checkPcbTracesOutOfBoard(circuitJson)
   ];
 }