@tscircuit/checks 0.0.186 → 0.0.188

package/dist/index.js

@@ -799,23 +799,6 @@ var getTraceSegments = (circuitJson) => {
     return segments;
   });
 };
-var getTraceCenter = (segment) => {
-  const routePoints = segment._pcbTrace.route.flatMap((routePoint) => {
-    if (routePoint.route_type === "through_pad") {
-      return [routePoint.start, routePoint.end];
-    }
-    return [{ x: routePoint.x, y: routePoint.y }];
-  });
-  const firstPoint = routePoints[0];
-  const lastPoint = routePoints[routePoints.length - 1];
-  if (!firstPoint || !lastPoint) {
-    return midpoint(
-      { x: segment.x1, y: segment.y1 },
-      { x: segment.x2, y: segment.y2 }
-    );
-  }
-  return midpoint(firstPoint, lastPoint);
-};
 var getCenterBetweenCopperEdges = ({
   tracePoint,
   obstaclePoint,
@@ -828,6 +811,15 @@ var getCenterBetweenCopperEdges = ({
   if (distance3 === 0) return midpoint(tracePoint, obstaclePoint);
   const unitX = dx / distance3;
   const unitY = dy / distance3;
+  if (distance3 <= traceRadius + obstacleRadius) {
+    const overlapStart = Math.max(-traceRadius, distance3 - obstacleRadius);
+    const overlapEnd = Math.min(traceRadius, distance3 + obstacleRadius);
+    const offset = (overlapStart + overlapEnd) / 2;
+    return {
+      x: tracePoint.x + unitX * offset,
+      y: tracePoint.y + unitY * offset
+    };
+  }
   const traceEdge = {
     x: tracePoint.x + unitX * traceRadius,
     y: tracePoint.y + unitY * traceRadius
@@ -887,6 +879,16 @@ var getTraceObstacleClearance = (segment, obstacle) => {
   };
 };
 var isTraceObstacleOverlap = (gap) => gap <= 0;
+var getViaPadClearanceCenter = (via, pad) => getTraceObstacleClearance(
+  {
+    x1: via.x,
+    y1: via.y,
+    x2: via.x,
+    y2: via.y,
+    thickness: via.outer_diameter
+  },
+  pad
+).center;
 
 // lib/data-structures/SpatialIndex.ts
 var SpatialObjectIndex = class {
@@ -3342,8 +3344,49 @@ import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCirc
 // lib/check-pcb-components-overlap/doPcbElementsOverlap.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements4 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap2 } from "@tscircuit/math-utils";
+var isCourtyardElement = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
+var getCourtyardId = (courtyard) => {
+  switch (courtyard.type) {
+    case "pcb_courtyard_circle":
+      return courtyard.pcb_courtyard_circle_id;
+    case "pcb_courtyard_outline":
+      return courtyard.pcb_courtyard_outline_id;
+    case "pcb_courtyard_polygon":
+      return courtyard.pcb_courtyard_polygon_id;
+    case "pcb_courtyard_rect":
+      return courtyard.pcb_courtyard_rect_id;
+  }
+};
+var courtyardToKeepout = (courtyard) => {
+  const common = {
+    type: "pcb_keepout",
+    pcb_keepout_id: getCourtyardId(courtyard),
+    layers: [courtyard.layer]
+  };
+  if (courtyard.type === "pcb_courtyard_circle") {
+    return {
+      ...common,
+      shape: "circle",
+      center: courtyard.center,
+      radius: courtyard.radius
+    };
+  }
+  const outline = courtyard.type === "pcb_courtyard_rect" ? getRotatedRectPoints({
+    x: courtyard.center.x,
+    y: courtyard.center.y,
+    width: courtyard.width,
+    height: courtyard.height,
+    ccwRotation: courtyard.ccw_rotation ?? 0
+  }) : courtyard.type === "pcb_courtyard_polygon" ? courtyard.points : courtyard.outline;
+  return {
+    ...common,
+    shape: "outline",
+    outline,
+    stroke_width: 0
+  };
+};
 function getElementLayers(elem) {
-  if (elem.type === "pcb_courtyard_circle" || elem.type === "pcb_courtyard_outline" || elem.type === "pcb_courtyard_polygon" || elem.type === "pcb_courtyard_rect") {
+  if (isCourtyardElement(elem)) {
     return [elem.layer];
   }
   return getLayersOfPcbElement(elem);
@@ -3359,13 +3402,20 @@ function doPcbElementsOverlap(elem1, elem2) {
   if (elem1.type === "pcb_smtpad" && elem2.type === "pcb_smtpad") {
     return getPadToPadGap(elem1, elem2) <= 0;
   }
+  if (elem1.type === "pcb_plated_hole" && isCourtyardElement(elem2)) {
+    return getPadToPadGap(elem1, courtyardToKeepout(elem2)) <= 0;
+  }
+  if (isCourtyardElement(elem1) && elem2.type === "pcb_plated_hole") {
+    return getPadToPadGap(elem2, courtyardToKeepout(elem1)) <= 0;
+  }
   const bounds1 = getBoundsOfPcbElements4([elem1]);
   const bounds2 = getBoundsOfPcbElements4([elem2]);
   return doBoundsOverlap2(bounds1, bounds2);
 }
 
 // lib/check-pcb-components-overlap/checkPcbComponentOverlap.ts
-var isCourtyardElement = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
+var isCourtyardElement2 = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
+var isHoleElement = (element) => element.type === "pcb_hole" || element.type === "pcb_plated_hole";
 var formatOverlapElementDescription = (circuitJson, element) => {
   if ("pcb_port_id" in element && element.pcb_port_id) {
     return getReadableNameForPort(circuitJson, element.pcb_port_id);
@@ -3380,7 +3430,7 @@ function checkPcbComponentOverlap(circuitJson) {
   const smtPads = cju6(circuitJson).pcb_smtpad.list();
   const platedHoles = cju6(circuitJson).pcb_plated_hole.list();
   const holes = cju6(circuitJson).pcb_hole.list();
-  const courtyards = circuitJson.filter(isCourtyardElement);
+  const courtyards = circuitJson.filter(isCourtyardElement2);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
     const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId4(pad)}`;
@@ -3441,7 +3491,7 @@ function checkPcbComponentOverlap(circuitJson) {
         for (const elem2 of comp2.elements) {
           const id1 = getPrimaryId4(elem1);
           const id2 = getPrimaryId4(elem2);
-          if ((isCourtyardElement(elem1) || isCourtyardElement(elem2)) && elem1.type !== "pcb_hole" && elem2.type !== "pcb_hole") {
+          if ((isCourtyardElement2(elem1) || isCourtyardElement2(elem2)) && !isHoleElement(elem1) && !isHoleElement(elem2)) {
             continue;
           }
           if (elem1.type === "pcb_smtpad" && elem2.type === "pcb_smtpad" && connMap.areIdsConnected(id1, id2)) {
@@ -3792,7 +3842,7 @@ function checkPadTraceClearance(circuitJson, {
       if (!getLayersOfPcbElement(pad).includes(segment.layer)) continue;
       if (connMap.areIdsConnected(segment.pcb_trace_id, padId)) continue;
       const pairId = `${padId}_${segment.pcb_trace_id}`;
-      const { gap } = getTraceObstacleClearance(segment, pad);
+      const { gap, center } = getTraceObstacleClearance(segment, pad);
       if (isTraceObstacleOverlap(gap)) {
         errors.delete(pairId);
         overlappingPairIds.add(pairId);
@@ -3809,7 +3859,7 @@ function checkPadTraceClearance(circuitJson, {
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
         actual_clearance: gap,
-        center: getTraceCenter(segment)
+        center
       };
       const current = errors.get(pairId);
       if (!current || gap < current.gap) {
@@ -3844,7 +3894,7 @@ function checkViaTraceClearance(circuitJson, {
       if (connMap.areIdsConnected(segment.pcb_trace_id, via.pcb_via_id))
         continue;
       const pairId = `${via.pcb_via_id}_${segment.pcb_trace_id}`;
-      const { gap } = getTraceObstacleClearance(segment, via);
+      const { gap, center } = getTraceObstacleClearance(segment, via);
       if (isTraceObstacleOverlap(gap)) {
         errors.delete(pairId);
         overlappingPairIds.add(pairId);
@@ -3861,7 +3911,7 @@ function checkViaTraceClearance(circuitJson, {
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
         actual_clearance: gap,
-        center: getTraceCenter(segment)
+        center
       };
       const current = errors.get(pairId);
       if (!current || gap < current.gap) {
@@ -3914,8 +3964,6 @@ function checkViaPadClearance(circuitJson, {
       if (connMap.areIdsConnected(via.pcb_via_id, padId)) continue;
       const gap = getPadToPadGap(via, pad);
       if (gap + EPSILON >= requiredClearance) continue;
-      const viaCenter = getPadCenter(via);
-      const padCenter = getPadCenter(pad);
       errors.push({
         type: "pcb_pad_pad_clearance_error",
         pcb_pad_pad_clearance_error_id: `via_pad_clearance_${via.pcb_via_id}_${padId}`,
@@ -3924,10 +3972,7 @@ function checkViaPadClearance(circuitJson, {
         pcb_pad_ids: [via.pcb_via_id, padId],
         minimum_clearance: requiredClearance,
         actual_clearance: gap,
-        center: {
-          x: (viaCenter.x + padCenter.x) / 2,
-          y: (viaCenter.y + padCenter.y) / 2
-        }
+        center: getViaPadClearanceCenter(via, pad)
       });
     }
   }
@@ -4764,7 +4809,7 @@ function checkCourtyardOverlap(circuitJson) {
 
 // lib/check-testpoint-accessibility.ts
 import { isPointInsidePolygon as isPointInsidePolygon3 } from "@tscircuit/math-utils";
-var isCourtyardElement2 = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
+var isCourtyardElement3 = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
 var isPointInsideCourtyard = (point, courtyard) => {
   if (courtyard.type === "pcb_courtyard_circle") {
     const dx = point.x - courtyard.center.x;
@@ -4807,7 +4852,7 @@ function checkTestPointAccessibility(circuitJson) {
   const testPointComponents = circuitJson.filter(
     (element) => element.type === "pcb_component" && sourceTestPointIds.has(element.source_component_id)
   );
-  const courtyards = circuitJson.filter(isCourtyardElement2);
+  const courtyards = circuitJson.filter(isCourtyardElement3);
   const errors = [];
   const reportedComponentPairs = /* @__PURE__ */ new Set();
   for (const testPoint of testPointComponents) {