@tscircuit/checks 0.0.161 → 0.0.163

package/README.md

@@ -28,7 +28,7 @@ and output an array of arrays for any issues found.
 | [`checkSourceTracesHavePcbTraces`](./lib/check-source-traces-have-pcb-traces.ts) | Returns `pcb_trace_error` when source traces are missing corresponding `pcb_trace` routes. |
 | [`checkTracesAreContiguous`](./lib/check-traces-are-contiguous/check-traces-are-contiguous.ts) | Returns `pcb_trace_error` when trace endpoints are floating or do not connect as expected. |
 | [`checkViasOffBoard`](./lib/check-pcb-components-out-of-board/checkViasOffBoard.ts) | Returns `pcb_placement_error` if any PCB via lies outside or crosses the board boundary. |
-| [`checkCopperToBoardEdgeClearance`](./lib/check-copper-to-board-edge-clearance.ts) | Checks via, SMT-pad, and plated-hole copper against the polygon board outline and required edge clearance. |
+| [`checkCopperToBoardEdgeClearance`](./lib/check-copper-to-board-edge-clearance.ts) | Checks via, SMT-pad, plated-hole, and copper-pour geometry against the polygon board outline and required edge clearance. |
 
 ## Aggregate check runner functions
 

package/dist/index.d.ts

@@ -18,8 +18,9 @@ declare class NetManager {
 declare function checkViasOffBoard(circuitJson: AnyCircuitElement[]): PcbPlacementError[];
 
 /**
- * Checks the finished copper geometry of every via, SMT pad, and plated hole
- * against the real board outline and its configured edge-clearance rule.
+ * Checks the finished copper geometry of every via, SMT pad, plated hole, and
+ * copper pour against the real board outline and its configured edge-clearance
+ * rule.
  *
  * Component and footprint rotations are normally composed into Circuit JSON's
  * absolute coordinates and `ccw_rotation` fields. Polygon-pad plated holes are

package/dist/index.js

@@ -200,6 +200,7 @@ function getDistanceBetweenPoints(pointA, pointB) {
   return Math.sqrt((pointB.x - pointA.x) ** 2 + (pointB.y - pointA.y) ** 2);
 }
 var POINT_ON_SEGMENT_TOLERANCE_MM = 1e-9;
+var POINT_IN_PAD_TOLERANCE_MM = 1e-9;
 function isPointOnSegment(point, segment) {
   const crossProduct = (point.y - segment.start.y) * (segment.end.x - segment.start.x) - (point.x - segment.start.x) * (segment.end.y - segment.start.y);
   if (Math.abs(crossProduct) > POINT_ON_SEGMENT_TOLERANCE_MM) return false;
@@ -222,12 +223,12 @@ function isPointInPolygon(point, polygon) {
 function isPointInPad(point, pad) {
   if (pad.type === "pcb_smtpad") {
     if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.radius;
+      return getDistanceBetweenPoints(point, pad) <= pad.radius + POINT_IN_PAD_TOLERANCE_MM;
     }
     if (pad.shape === "rect") {
       const halfWidth = pad.width / 2;
       const halfHeight = pad.height / 2;
-      return Math.abs(point.x - pad.x) <= halfWidth && Math.abs(point.y - pad.y) <= halfHeight;
+      return Math.abs(point.x - pad.x) <= halfWidth + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM;
     }
     if (pad.shape === "rotated_rect") {
       return isPointInPolygon(point, getPolygonPointsForPad(pad));
@@ -235,12 +236,12 @@ function isPointInPad(point, pad) {
     if (pad.shape === "pill" || pad.shape === "rotated_pill") {
       if (pad.shape === "rotated_pill") {
         const pill2 = getPillCenterLineForPad(pad);
-        return pointToSegmentDistance(point, pill2.start, pill2.end) <= pill2.radius;
+        return pointToSegmentDistance(point, pill2.start, pill2.end) <= pill2.radius + POINT_IN_PAD_TOLERANCE_MM;
       }
       const halfWidth = pad.width / 2;
       const halfHeight = pad.height / 2;
       const radius = pad.radius;
-      if (Math.abs(point.x - pad.x) <= halfWidth - radius && Math.abs(point.y - pad.y) <= halfHeight) {
+      if (Math.abs(point.x - pad.x) <= halfWidth - radius + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM) {
         return true;
       }
       const cornerX = Math.max(
@@ -251,7 +252,8 @@ function isPointInPad(point, pad) {
         Math.abs(point.y - pad.y) - (halfHeight - radius),
         0
       );
-      return cornerX * cornerX + cornerY * cornerY <= radius * radius;
+      const radiusWithTolerance = radius + POINT_IN_PAD_TOLERANCE_MM;
+      return cornerX * cornerX + cornerY * cornerY <= radiusWithTolerance * radiusWithTolerance;
     }
     if (pad.shape === "polygon") {
       return isPointInPolygon(point, pad.points);
@@ -259,13 +261,13 @@ function isPointInPad(point, pad) {
   }
   if (pad.type === "pcb_plated_hole") {
     if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2;
+      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2 + POINT_IN_PAD_TOLERANCE_MM;
     }
     if ("rect_pad_width" in pad && "rect_pad_height" in pad) {
       return isPointInPolygon(point, getPolygonPointsForPad(pad));
     }
     if (pad.shape === "oval" || pad.shape === "pill") {
-      return Math.abs(point.x - pad.x) <= pad.outer_width / 2 && Math.abs(point.y - pad.y) <= pad.outer_height / 2;
+      return Math.abs(point.x - pad.x) <= pad.outer_width / 2 + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= pad.outer_height / 2 + POINT_IN_PAD_TOLERANCE_MM;
     }
   }
   return false;
@@ -1536,6 +1538,57 @@ var pointsToPolygon = (points) => {
   if (points.length < 3) return null;
   return new Flatten.Polygon(points.map(({ x, y }) => new Flatten.Point(x, y)));
 };
+var brepRingToPolygon = (vertices) => {
+  const ring = vertices.filter((vertex, index) => {
+    const previous = vertices[index - 1];
+    return !previous || Math.abs(previous.x - vertex.x) > GEOMETRY_EPSILON || Math.abs(previous.y - vertex.y) > GEOMETRY_EPSILON;
+  });
+  if (ring.length > 1 && Math.abs(ring[0].x - ring.at(-1).x) <= GEOMETRY_EPSILON && Math.abs(ring[0].y - ring.at(-1).y) <= GEOMETRY_EPSILON) {
+    ring.pop();
+  }
+  if (ring.length < 3) return null;
+  const edges = [];
+  for (let index = 0; index < ring.length; index++) {
+    const start = ring[index];
+    const end = ring[(index + 1) % ring.length];
+    const startPoint = new Flatten.Point(start.x, start.y);
+    const endPoint = new Flatten.Point(end.x, end.y);
+    const bulge = start.bulge ?? 0;
+    if (Math.abs(bulge) <= GEOMETRY_EPSILON) {
+      edges.push(new Flatten.Segment(startPoint, endPoint));
+      continue;
+    }
+    const chordLength = startPoint.distanceTo(endPoint)[0];
+    if (chordLength <= GEOMETRY_EPSILON) continue;
+    const midpoint2 = {
+      x: (start.x + end.x) / 2,
+      y: (start.y + end.y) / 2
+    };
+    const leftNormal = {
+      x: -(end.y - start.y) / chordLength,
+      y: (end.x - start.x) / chordLength
+    };
+    const centerOffset = chordLength * (1 - bulge * bulge) / (4 * bulge);
+    const center = new Flatten.Point(
+      midpoint2.x + leftNormal.x * centerOffset,
+      midpoint2.y + leftNormal.y * centerOffset
+    );
+    const radius = chordLength * (1 + bulge * bulge) / (4 * Math.abs(bulge));
+    edges.push(
+      new Flatten.Arc(
+        center,
+        radius,
+        Math.atan2(start.y - center.y, start.x - center.x),
+        Math.atan2(end.y - center.y, end.x - center.x),
+        bulge > 0
+      )
+    );
+  }
+  if (edges.length < 3) return null;
+  const polygon = new Flatten.Polygon();
+  polygon.addFace(edges);
+  return polygon;
+};
 var boardToPolygon = (board) => {
   if (board.outline && board.outline.length >= 3) {
     return pointsToPolygon(board.outline);
@@ -1773,22 +1826,45 @@ var getCopperGeometry = (element, componentCcwRotationsById) => {
     };
   }
   if (element.type === "pcb_smtpad") return getSmtPadGeometry(element);
-  return getPlatedHoleGeometry(
-    element,
-    element.pcb_component_id ? componentCcwRotationsById.get(
-      toPcbComponentId(element.pcb_component_id)
-    ) ?? 0 : 0
-  );
+  if (element.type === "pcb_plated_hole") {
+    return getPlatedHoleGeometry(
+      element,
+      element.pcb_component_id ? componentCcwRotationsById.get(
+        toPcbComponentId(element.pcb_component_id)
+      ) ?? 0 : 0
+    );
+  }
+  let polygon;
+  switch (element.shape) {
+    case "rect":
+      polygon = getRectanglePolygon({
+        x: element.center.x,
+        y: element.center.y,
+        width: element.width,
+        height: element.height,
+        ccwRotationDegrees: element.rotation ?? 0
+      });
+      break;
+    case "polygon":
+      polygon = pointsToPolygon(element.points);
+      break;
+    case "brep":
+      polygon = brepRingToPolygon(element.brep_shape.outer_ring.vertices);
+      break;
+  }
+  return polygon ? { kind: "shapes", shapes: [polygon] } : null;
 };
 var getCopperElementId = (element) => {
   if (element.type === "pcb_via") return element.pcb_via_id;
   if (element.type === "pcb_smtpad") return element.pcb_smtpad_id;
-  return element.pcb_plated_hole_id;
+  if (element.type === "pcb_plated_hole") return element.pcb_plated_hole_id;
+  return element.pcb_copper_pour_id;
 };
 var getCopperElementLabel = (element) => {
   if (element.type === "pcb_via") return "Via";
   if (element.type === "pcb_smtpad") return "SMT pad";
-  return "Plated hole";
+  if (element.type === "pcb_plated_hole") return "Plated hole";
+  return "Copper pour";
 };
 var measureClearance = (board, geometry) => {
   if (geometry.kind === "shapes") {
@@ -1816,7 +1892,7 @@ function checkCopperToBoardEdgeClearance(circuitJson) {
   const requiredClearance = getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
   if (requiredClearance === void 0) return [];
   const copperElements = circuitJson.filter(
-    (element) => element.type === "pcb_via" || element.type === "pcb_smtpad" || element.type === "pcb_plated_hole"
+    (element) => element.type === "pcb_via" || element.type === "pcb_smtpad" || element.type === "pcb_plated_hole" || element.type === "pcb_copper_pour"
   );
   const componentCcwRotationsById = new Map(
     circuitJson.filter(