@tscircuit/checks 0.0.204 → 0.0.206

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
@@ -1339,7 +1431,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 +1446,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,
@@ -1596,7 +1691,35 @@ var getPolygonShape = (pad) => {
     ]
   };
 };
+var getRoundedPadCore = (pad) => {
+  if (pad.type !== "pcb_smtpad" || pad.shape !== "rect" && pad.shape !== "rotated_rect" || !pad.corner_radius || pad.corner_radius <= 0)
+    return null;
+  const radius = Math.min(pad.corner_radius, pad.width / 2, pad.height / 2);
+  if (radius === Math.min(pad.width, pad.height) / 2) {
+    const core = {
+      ...pad,
+      shape: "rotated_pill",
+      radius,
+      ccw_rotation: pad.shape === "rotated_rect" ? pad.ccw_rotation : 0
+    };
+    return { core, radius: 0 };
+  }
+  return {
+    core: {
+      ...pad,
+      width: pad.width - 2 * radius,
+      height: pad.height - 2 * radius,
+      corner_radius: 0
+    },
+    radius
+  };
+};
 var getPadToPadGap = (padA, padB) => {
+  const roundedA = getRoundedPadCore(padA);
+  const roundedB = getRoundedPadCore(padB);
+  if (roundedA || roundedB) {
+    return getPadToPadGap(roundedA?.core ?? padA, roundedB?.core ?? padB) - (roundedA?.radius ?? 0) - (roundedB?.radius ?? 0);
+  }
   if (isPillPad(padA) && isPillPad(padB)) {
     const pillA = getPillCenterLineForPad(padA);
     const pillB = getPillCenterLineForPad(padB);
@@ -1715,6 +1838,9 @@ var getCenterBetweenCopperEdges = ({
   return midpoint(traceEdge, obstacleEdge);
 };
 var getTraceObstacleClearance = (segment, obstacle) => {
+  const rounded = getRoundedPadCore(obstacle);
+  if (rounded) obstacle = rounded.core;
+  const obstacleRadius = rounded?.radius ?? 0;
   const start = { x: segment.x1, y: segment.y1 };
   const end = { x: segment.x2, y: segment.y2 };
   const traceRadius = segment.thickness / 2;
@@ -1753,12 +1879,12 @@ var getTraceObstacleClearance = (segment, obstacle) => {
     getPolygonShape(obstacle).points
   );
   return {
-    gap: clearance.distance - traceRadius,
+    gap: clearance.distance - traceRadius - obstacleRadius,
     center: getCenterBetweenCopperEdges({
       tracePoint: clearance.tracePoint,
       obstaclePoint: clearance.obstaclePoint,
       traceRadius,
-      obstacleRadius: 0
+      obstacleRadius
     })
   };
 };
@@ -3248,8 +3374,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"
@@ -3263,7 +3391,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,
@@ -3311,8 +3439,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
@@ -3576,7 +3703,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"
@@ -3594,8 +3724,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);
@@ -5175,6 +5305,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(
@@ -5700,20 +5833,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)
   ];
 }