@tscircuit/checks 0.0.125 → 0.0.126

package/dist/index.js

@@ -243,7 +243,7 @@ import {
   segmentToBoundsMinDistance,
   segmentToCircleMinDistance
 } from "@tscircuit/math-utils";
-import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
 import {
   getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
 } from "circuit-json-to-connectivity-map";
@@ -636,6 +636,156 @@ var clamp = (value, min, max) => {
 
 // lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
+
+// lib/check-each-pcb-trace-non-overlapping/segment-to-polygon-clearance.ts
+import {
+  distSq,
+  getSegmentIntersection,
+  isPointInsidePolygon,
+  pointToSegmentClosestPoint,
+  segmentToSegmentMinDistance
+} from "@tscircuit/math-utils";
+var rotatePoint = (point, angleDegrees) => {
+  const angle = angleDegrees * Math.PI / 180;
+  return {
+    x: point.x * Math.cos(angle) - point.y * Math.sin(angle),
+    y: point.x * Math.sin(angle) + point.y * Math.cos(angle)
+  };
+};
+var getRotatedRectPoints = ({
+  x,
+  y,
+  width,
+  height,
+  ccwRotation
+}) => {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ].map((point) => {
+    const rotated = rotatePoint(point, ccwRotation);
+    return { x: x + rotated.x, y: y + rotated.y };
+  });
+};
+var getPolygonPointsForPad = (pad) => {
+  if (pad.type === "pcb_smtpad") {
+    if (pad.shape === "polygon") return pad.points;
+    if (pad.shape === "rotated_rect") {
+      return getRotatedRectPoints({
+        x: pad.x,
+        y: pad.y,
+        width: pad.width,
+        height: pad.height,
+        ccwRotation: pad.ccw_rotation
+      });
+    }
+  }
+  if (pad.type === "pcb_plated_hole" && "rect_pad_width" in pad && "rect_pad_height" in pad) {
+    return getRotatedRectPoints({
+      x: pad.x,
+      y: pad.y,
+      width: pad.rect_pad_width,
+      height: pad.rect_pad_height,
+      ccwRotation: "rect_ccw_rotation" in pad && typeof pad.rect_ccw_rotation === "number" ? pad.rect_ccw_rotation : 0
+    });
+  }
+  throw new Error(
+    `Expected polygonal pad geometry, got ${pad.type} with shape "${pad.shape}"`
+  );
+};
+var getPolygonEdges = (points) => points.map(
+  (point, index) => [point, points[(index + 1) % points.length]]
+);
+var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
+  const intersection = getSegmentIntersection(a1, a2, b1, b2);
+  if (intersection) {
+    return {
+      distance: 0,
+      pointOnA: intersection,
+      pointOnB: intersection,
+      center: intersection
+    };
+  }
+  const candidates = [
+    { pointOnA: a1, pointOnB: pointToSegmentClosestPoint(a1, b1, b2) },
+    { pointOnA: a2, pointOnB: pointToSegmentClosestPoint(a2, b1, b2) },
+    { pointOnA: pointToSegmentClosestPoint(b1, a1, a2), pointOnB: b1 },
+    { pointOnA: pointToSegmentClosestPoint(b2, a1, a2), pointOnB: b2 }
+  ];
+  let best = candidates[0];
+  let bestDistanceSquared = distSq(best.pointOnA, best.pointOnB);
+  for (const candidate of candidates.slice(1)) {
+    const candidateDistanceSquared = distSq(
+      candidate.pointOnA,
+      candidate.pointOnB
+    );
+    if (candidateDistanceSquared < bestDistanceSquared) {
+      best = candidate;
+      bestDistanceSquared = candidateDistanceSquared;
+    }
+  }
+  return {
+    distance: segmentToSegmentMinDistance(a1, a2, b1, b2),
+    pointOnA: best.pointOnA,
+    pointOnB: best.pointOnB,
+    center: {
+      x: (best.pointOnA.x + best.pointOnB.x) / 2,
+      y: (best.pointOnA.y + best.pointOnB.y) / 2
+    }
+  };
+};
+var getSegmentToPolygonClearance = (segment, polygon) => {
+  const start = { x: segment.x1, y: segment.y1 };
+  const end = { x: segment.x2, y: segment.y2 };
+  if (polygon.length < 3) {
+    return { distance: Number.POSITIVE_INFINITY, center: start };
+  }
+  const intersections = getPolygonEdges(polygon).map(
+    ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
+  ).filter((point) => point !== null);
+  if (intersections.length > 0) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    intersections.sort((a, b) => {
+      const ta = ((a.x - start.x) * dx + (a.y - start.y) * dy) / lengthSquared;
+      const tb = ((b.x - start.x) * dx + (b.y - start.y) * dy) / lengthSquared;
+      return ta - tb;
+    });
+    return { distance: 0, center: intersections[0] };
+  }
+  if (isPointInsidePolygon(start, polygon) || isPointInsidePolygon(end, polygon)) {
+    return {
+      distance: 0,
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      }
+    };
+  }
+  let best = getClosestPointsBetweenSegments(
+    start,
+    end,
+    polygon[0],
+    polygon[1]
+  );
+  for (const [edgeStart, edgeEnd] of getPolygonEdges(polygon).slice(1)) {
+    const candidate = getClosestPointsBetweenSegments(
+      start,
+      end,
+      edgeStart,
+      edgeEnd
+    );
+    if (candidate.distance < best.distance) best = candidate;
+  }
+  return { distance: best.distance, center: best.center };
+};
+
+// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
 var getCollidableBounds = (collidable) => {
   if (collidable.type === "pcb_trace_segment") {
     return {
@@ -645,6 +795,18 @@ var getCollidableBounds = (collidable) => {
       maxY: Math.max(collidable.y1, collidable.y2)
     };
   }
+  if (collidable.type === "pcb_smtpad" || collidable.type === "pcb_plated_hole") {
+    const isPolygon = collidable.type === "pcb_smtpad" && (collidable.shape === "rotated_rect" || collidable.shape === "polygon") || collidable.type === "pcb_plated_hole" && "rect_pad_width" in collidable && "rect_pad_height" in collidable;
+    if (isPolygon) {
+      const polygonPoints = getPolygonPointsForPad(collidable);
+      return {
+        minX: Math.min(...polygonPoints.map((point) => point.x)),
+        minY: Math.min(...polygonPoints.map((point) => point.y)),
+        maxX: Math.max(...polygonPoints.map((point) => point.x)),
+        maxY: Math.max(...polygonPoints.map((point) => point.y))
+      };
+    }
+  }
   return getBoundsOfPcbElements2([collidable]);
 };
 
@@ -763,7 +925,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         if (segmentA.layer !== segmentB.layer) continue;
         if (connMap.areIdsConnected(segmentA.pcb_trace_id, segmentB.pcb_trace_id))
           continue;
-        const gap2 = segmentToSegmentMinDistance(
+        const gap2 = segmentToSegmentMinDistance2(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: segmentB.x1, y: segmentB.y1 },
@@ -838,6 +1000,40 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
           ].filter(Boolean)
         });
       }
+      const isPolygon = obj.type === "pcb_smtpad" && (obj.shape === "rotated_rect" || obj.shape === "polygon") || obj.type === "pcb_plated_hole" && "rect_pad_width" in obj && "rect_pad_height" in obj;
+      if (isPolygon) {
+        const padOutline = getPolygonPointsForPad(obj);
+        const { distance: distance4, center } = getSegmentToPolygonClearance(
+          segmentA,
+          padOutline
+        );
+        const gap2 = distance4 - segmentA.thickness / 2;
+        if (gap2 > minClearance - EPSILON) continue;
+        const pcb_trace_error_id = `overlap_${segmentA.pcb_trace_id}_${primaryObjId}`;
+        if (errorIds.has(pcb_trace_error_id)) continue;
+        errorIds.add(pcb_trace_error_id);
+        errors.push({
+          type: "pcb_trace_error",
+          error_type: "pcb_trace_error",
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap2
+          ),
+          pcb_trace_id: segmentA.pcb_trace_id,
+          center,
+          source_trace_id: "",
+          pcb_trace_error_id,
+          pcb_component_ids: [
+            "pcb_component_id" in obj ? obj.pcb_component_id : void 0
+          ].filter(Boolean),
+          pcb_port_ids: [
+            ...getPcbPortIdsConnectedToTraces([segmentA._pcbTrace]),
+            "pcb_port_id" in obj ? obj.pcb_port_id : void 0
+          ].filter(Boolean)
+        });
+        continue;
+      }
       const gap = segmentToBoundsMinDistance(
         { x: segmentA.x1, y: segmentA.y1 },
         { x: segmentA.x2, y: segmentA.y2 },
@@ -1041,11 +1237,11 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
     });
   }
   const matrix = rotateDEG(rotationDeg, componentCenter.x, componentCenter.y);
-  const rotatePoint = (pt) => {
+  const rotatePoint2 = (pt) => {
     const p = applyToPoint(matrix, pt);
     return new Flatten.Point(p.x, p.y);
   };
-  const rotatedPoints = corners.concat(midpoints).map(rotatePoint);
+  const rotatedPoints = corners.concat(midpoints).map(rotatePoint2);
   let maxDistance = 0;
   for (const pt of rotatedPoints) {
     if (!boardPoly.contains(pt)) {
@@ -1420,7 +1616,7 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
 
 // lib/check-trace-out-of-board/checkTraceOutOfBoard.ts
 import { cju as cju3 } from "@tscircuit/circuit-json-util";
-import { segmentToSegmentMinDistance as segmentToSegmentMinDistance2 } from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } from "@tscircuit/math-utils";
 function getBoardPolygonPoints(board) {
   if (board.outline && board.outline.length > 0) {
     return board.outline.map((p) => ({ x: p.x, y: p.y }));
@@ -1464,7 +1660,7 @@ function checkPcbTracesOutOfBoard(circuitJson, config = {}) {
       for (let j = 0; j < boardPoints.length; j++) {
         const edgeStart = boardPoints[j];
         const edgeEnd = boardPoints[(j + 1) % boardPoints.length];
-        const distance4 = segmentToSegmentMinDistance2(
+        const distance4 = segmentToSegmentMinDistance3(
           segmentStart,
           segmentEnd,
           edgeStart,
@@ -2245,7 +2441,7 @@ function checkConnectorAccessibleOrientation(circuitJson) {
 // lib/check-courtyard-overlap/checkCourtyardOverlap.ts
 import {
   doSegmentsIntersect,
-  isPointInsidePolygon
+  isPointInsidePolygon as isPointInsidePolygon2
 } from "@tscircuit/math-utils";
 function getCourtyardPolygon(el) {
   if (el.type === "pcb_courtyard_rect") {
@@ -2291,8 +2487,8 @@ function getComponentName2(circuitJson, pcbComponentId) {
   return pcbComponentId;
 }
 function polygonsOverlap(polyA, polyB) {
-  if (polyA.some((p) => isPointInsidePolygon(p, polyB))) return true;
-  if (polyB.some((p) => isPointInsidePolygon(p, polyA))) return true;
+  if (polyA.some((p) => isPointInsidePolygon2(p, polyB))) return true;
+  if (polyB.some((p) => isPointInsidePolygon2(p, polyA))) return true;
   for (let i = 0; i < polyA.length; i++) {
     const a1 = polyA[i];
     const a2 = polyA[(i + 1) % polyA.length];