@tscircuit/checks 0.0.125 → 0.0.127

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";
@@ -572,7 +572,7 @@ var getClosestPointBetweenSegments = (segmentA, segmentB) => {
   };
   const dx = closestOnA.x - closestOnB.x;
   const dy = closestOnA.y - closestOnB.y;
-  const distance4 = Math.sqrt(dx * dx + dy * dy);
+  const distance3 = Math.sqrt(dx * dx + dy * dy);
   const averagePoint = {
     x: (closestOnA.x + closestOnB.x) / 2,
     y: (closestOnA.y + closestOnB.y) / 2
@@ -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 },
@@ -804,12 +966,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
       const isCircular = obj.type === "pcb_via" || obj.type === "pcb_plated_hole" && obj.shape === "circle" || obj.type === "pcb_hole" || obj.type === "pcb_smtpad" && obj.shape === "circle";
       if (isCircular) {
         const radius = getRadiusOfCircuitJsonElement(obj);
-        const distance4 = segmentToCircleMinDistance(
+        const distance3 = segmentToCircleMinDistance(
           { x: segmentA.x1, y: segmentA.y1 },
           { x: segmentA.x2, y: segmentA.y2 },
           { x: obj.x, y: obj.y, radius }
         );
-        const gap2 = distance4 - segmentA.thickness / 2;
+        const gap2 = distance3 - 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;
@@ -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: distance3, center } = getSegmentToPolygonClearance(
+          segmentA,
+          padOutline
+        );
+        const gap2 = distance3 - 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,14 +1660,14 @@ 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 distance3 = segmentToSegmentMinDistance3(
           segmentStart,
           segmentEnd,
           edgeStart,
           edgeEnd
         );
-        if (distance4 < minDistance) {
-          minDistance = distance4;
+        if (distance3 < minDistance) {
+          minDistance = distance3;
         }
       }
       const minimumDistance = traceWidth / 2 + margin;
@@ -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];
@@ -2349,13 +2545,22 @@ function checkCourtyardOverlap(circuitJson) {
 }
 
 // lib/check-traces-are-contiguous/is-point-in-pad.ts
-function distance3(x1, y1, x2, y2) {
-  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+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;
+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;
+  const dotProduct = (point.x - segment.start.x) * (segment.end.x - segment.start.x) + (point.y - segment.start.y) * (segment.end.y - segment.start.y);
+  if (dotProduct < -POINT_ON_SEGMENT_TOLERANCE_MM) return false;
+  const squaredLength = (segment.end.x - segment.start.x) ** 2 + (segment.end.y - segment.start.y) ** 2;
+  return dotProduct <= squaredLength + POINT_ON_SEGMENT_TOLERANCE_MM;
 }
 function isPointInPad(point, pad) {
   if (pad.type === "pcb_smtpad") {
     if (pad.shape === "circle") {
-      return distance3(point.x, point.y, pad.x, pad.y) <= pad.radius;
+      return getDistanceBetweenPoints(point, pad) <= pad.radius;
     }
     if (pad.shape === "rect") {
       const halfWidth = pad.width / 2;
@@ -2387,10 +2592,21 @@ function isPointInPad(point, pad) {
       );
       return cornerX * cornerX + cornerY * cornerY <= radius * radius;
     }
+    if (pad.shape === "polygon") {
+      let inside = false;
+      for (let i = 0, j = pad.points.length - 1; i < pad.points.length; j = i++) {
+        const pi = pad.points[i];
+        const pj = pad.points[j];
+        if (isPointOnSegment(point, { start: pi, end: pj })) return true;
+        const intersects = pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x;
+        if (intersects) inside = !inside;
+      }
+      return inside;
+    }
   }
   if (pad.type === "pcb_plated_hole") {
     if (pad.shape === "circle") {
-      return distance3(point.x, point.y, pad.x, pad.y) <= pad.outer_diameter / 2;
+      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2;
     }
     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;
@@ -2430,12 +2646,15 @@ function checkTracesAreContiguous(circuitJson) {
   const padMap = /* @__PURE__ */ new Map();
   for (const pad of pcbSmtPads) {
     if (pad.pcb_port_id) {
-      padMap.set(pad.pcb_port_id, pad);
+      padMap.set(pad.pcb_port_id, [...padMap.get(pad.pcb_port_id) ?? [], pad]);
     }
   }
   for (const hole of pcbPlatedHoles) {
     if (hole.pcb_port_id) {
-      padMap.set(hole.pcb_port_id, hole);
+      padMap.set(hole.pcb_port_id, [
+        ...padMap.get(hole.pcb_port_id) ?? [],
+        hole
+      ]);
     }
   }
   for (const trace of pcbTraces) {
@@ -2483,16 +2702,20 @@ function checkTracesAreContiguous(circuitJson) {
     );
     for (const port of expectedPorts) {
       if (!port.pcb_port_id) continue;
-      const pad = padMap.get(port.pcb_port_id);
-      if (!pad) continue;
-      const isFirstPointConnected = firstPoint.route_type === "wire" && isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad);
-      const isLastPointConnected = lastPoint.route_type === "wire" && isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad);
+      const pads = padMap.get(port.pcb_port_id);
+      if (!pads?.length) continue;
+      const isFirstPointConnected = firstPoint.route_type === "wire" && pads.some(
+        (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
+      );
+      const isLastPointConnected = lastPoint.route_type === "wire" && pads.some(
+        (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
+      );
       if (!isFirstPointConnected && !isLastPointConnected) {
         const portName = getReadableNameForPcbPort2(
           circuitJson,
           port.pcb_port_id
         ).replace("pcb_port", "");
-        const padType = pad.type.replace(/pcb_/, "");
+        const padType = pads[0].type.replace(/pcb_/, "");
         const errorCenter = {
           x: (firstPoint.x + lastPoint.x) / 2,
           y: (firstPoint.y + lastPoint.y) / 2
@@ -2514,11 +2737,15 @@ function checkTracesAreContiguous(circuitJson) {
       let firstConnectsToAnyPad = false;
       let lastConnectsToAnyPad = false;
       const endpointsAreSame = firstPoint.route_type === "wire" && lastPoint.route_type === "wire" && Math.abs(firstPoint.x - lastPoint.x) < 0.01 && Math.abs(firstPoint.y - lastPoint.y) < 0.01;
-      for (const [portId, pad] of padMap) {
-        if (firstPoint.route_type === "wire" && isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)) {
+      for (const pads of padMap.values()) {
+        if (firstPoint.route_type === "wire" && pads.some(
+          (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
+        )) {
           firstConnectsToAnyPad = true;
         }
-        if (lastPoint.route_type === "wire" && isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)) {
+        if (lastPoint.route_type === "wire" && pads.some(
+          (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
+        )) {
           lastConnectsToAnyPad = true;
         }
       }