@tscircuit/checks 0.0.121 → 0.0.123

package/dist/index.js

@@ -237,7 +237,16 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
 }
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { getReadableNameForElement as getReadableNameForElement2, cju } from "@tscircuit/circuit-json-util";
+import { cju, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
+import { getPrimaryId } from "@tscircuit/circuit-json-util";
+import {
+  segmentToBoundsMinDistance,
+  segmentToCircleMinDistance
+} from "@tscircuit/math-utils";
+import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
+import {
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
+} from "circuit-json-to-connectivity-map";
 
 // lib/data-structures/SpatialIndex.ts
 var SpatialObjectIndex = class {
@@ -338,37 +347,13 @@ var SpatialObjectIndex = class {
   }
 };
 
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
-} from "circuit-json-to-connectivity-map";
-
-// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
-import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
-var getCollidableBounds = (collidable) => {
-  if (collidable.type === "pcb_trace_segment") {
-    return {
-      minX: Math.min(collidable.x1, collidable.x2),
-      minY: Math.min(collidable.y1, collidable.y2),
-      maxX: Math.max(collidable.x1, collidable.x2),
-      maxY: Math.max(collidable.y1, collidable.y2)
-    };
-  }
-  return getBoundsOfPcbElements2([collidable]);
-};
-
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import {
-  segmentToBoundsMinDistance,
-  segmentToCircleMinDistance
-} from "@tscircuit/math-utils";
-
 // node_modules/@tscircuit/jlcpcb-manufacturing-specs/lib/jlcpcb-manufacturing-specs.ts
 var jlcMinTolerances = {
   min_trace_width: 0.1,
-  min_via_to_via_clearance: 0.1,
-  min_trace_to_pad_clearance: 0.1,
-  min_pad_to_pad_clearance: 0.1,
+  min_via_hole_edge_to_via_hole_edge_clearance: 0.1,
+  min_plated_hole_drill_edge_to_drill_edge_clearance: 0.15,
+  min_trace_to_pad_edge_clearance: 0.1,
+  min_pad_edge_to_pad_edge_clearance: 0.1,
   min_board_edge_clearance: 0.2,
   min_via_hole_diameter: 0.2,
   min_via_pad_diameter: 0.3
@@ -379,38 +364,128 @@ var DEFAULT_TRACE_MARGIN = 0.1;
 var DEFAULT_TRACE_THICKNESS = jlcMinTolerances.min_trace_width;
 var DEFAULT_VIA_DIAMETER = jlcMinTolerances.min_via_pad_diameter;
 var DEFAULT_VIA_BOARD_MARGIN = 0.3;
-var DEFAULT_SAME_NET_VIA_MARGIN = jlcMinTolerances.min_via_to_via_clearance;
-var DEFAULT_DIFFERENT_NET_VIA_MARGIN = jlcMinTolerances.min_via_to_via_clearance;
-var DEFAULT_PAD_PAD_CLEARANCE = jlcMinTolerances.min_pad_to_pad_clearance;
-var DEFAULT_PAD_TRACE_CLEARANCE = jlcMinTolerances.min_trace_to_pad_clearance;
+var DEFAULT_SAME_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
+var DEFAULT_DIFFERENT_NET_VIA_MARGIN = jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
+var DEFAULT_PAD_PAD_CLEARANCE = jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
+var DEFAULT_PAD_TRACE_CLEARANCE = jlcMinTolerances.min_trace_to_pad_edge_clearance;
 var EPSILON = 5e-3;
 
-// lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
-function getPcbPortIdsConnectedToTrace(trace) {
-  const connectedPcbPorts = /* @__PURE__ */ new Set();
-  for (const segment of trace.route) {
-    if (segment.route_type === "wire") {
-      if (segment.start_pcb_port_id)
-        connectedPcbPorts.add(segment.start_pcb_port_id);
-      if (segment.end_pcb_port_id)
-        connectedPcbPorts.add(segment.end_pcb_port_id);
-    }
+// lib/util/getLayersOfPcbElement.ts
+import { all_layers } from "circuit-json";
+function getLayersOfPcbElement(obj) {
+  if (obj.type === "pcb_trace_segment") {
+    return [obj.layer];
   }
-  return Array.from(connectedPcbPorts);
-}
-function getPcbPortIdsConnectedToTraces(traces) {
-  const connectedPorts = /* @__PURE__ */ new Set();
-  for (const trace of traces) {
-    for (const portId of getPcbPortIdsConnectedToTrace(trace)) {
-      connectedPorts.add(portId);
-    }
+  if (obj.type === "pcb_smtpad") {
+    return [obj.layer];
   }
-  return Array.from(connectedPorts);
+  if (obj.type === "pcb_plated_hole") {
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+  }
+  if (obj.type === "pcb_hole") {
+    return [...all_layers];
+  }
+  if (obj.type === "pcb_via") {
+    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
+  }
+  if (obj.type === "pcb_keepout") {
+    return Array.isArray(obj.layers) ? obj.layers : [];
+  }
+  return [];
 }
 
-// lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { segmentToSegmentMinDistance } from "@tscircuit/math-utils";
-import { getPrimaryId } from "@tscircuit/circuit-json-util";
+// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegmentAndBounds.ts
+var getClosestPointBetweenSegmentAndBounds = (segment, bounds) => {
+  const p1 = { x: segment.x1, y: segment.y1 };
+  const p2 = { x: segment.x2, y: segment.y2 };
+  const minX = bounds.minX;
+  const minY = bounds.minY;
+  const maxX = bounds.maxX;
+  const maxY = bounds.maxY;
+  if (p1.x === p2.x && p1.y === p2.y) {
+    const closestX = Math.max(minX, Math.min(maxX, p1.x));
+    const closestY = Math.max(minY, Math.min(maxY, p1.y));
+    if (closestX === p1.x && closestY === p1.y) {
+      return { x: p1.x, y: p1.y };
+    }
+    return { x: closestX, y: closestY };
+  }
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const tMinX = dx !== 0 ? (minX - p1.x) / dx : Number.NEGATIVE_INFINITY;
+  const tMaxX = dx !== 0 ? (maxX - p1.x) / dx : Number.POSITIVE_INFINITY;
+  const tMinY = dy !== 0 ? (minY - p1.y) / dy : Number.NEGATIVE_INFINITY;
+  const tMaxY = dy !== 0 ? (maxY - p1.y) / dy : Number.POSITIVE_INFINITY;
+  const tEnter = Math.max(Math.min(tMinX, tMaxX), Math.min(tMinY, tMaxY));
+  const tExit = Math.min(Math.max(tMinX, tMaxX), Math.max(tMinY, tMaxY));
+  if (tEnter <= tExit && tExit >= 0 && tEnter <= 1) {
+    const t = Math.max(0, Math.min(1, tEnter));
+    return {
+      x: p1.x + t * dx,
+      y: p1.y + t * dy
+    };
+  }
+  const closestToP1 = {
+    x: Math.max(minX, Math.min(maxX, p1.x)),
+    y: Math.max(minY, Math.min(maxY, p1.y))
+  };
+  const closestToP2 = {
+    x: Math.max(minX, Math.min(maxX, p2.x)),
+    y: Math.max(minY, Math.min(maxY, p2.y))
+  };
+  const distToP1Squared = (closestToP1.x - p1.x) ** 2 + (closestToP1.y - p1.y) ** 2;
+  const distToP2Squared = (closestToP2.x - p2.x) ** 2 + (closestToP2.y - p2.y) ** 2;
+  const edges = [
+    { start: { x: minX, y: minY }, end: { x: maxX, y: minY } },
+    // Bottom edge
+    { start: { x: maxX, y: minY }, end: { x: maxX, y: maxY } },
+    // Right edge
+    { start: { x: maxX, y: maxY }, end: { x: minX, y: maxY } },
+    // Top edge
+    { start: { x: minX, y: maxY }, end: { x: minX, y: minY } }
+    // Left edge
+  ];
+  let minDistance = Math.min(distToP1Squared, distToP2Squared);
+  let closestPoint = distToP1Squared <= distToP2Squared ? closestToP1 : closestToP2;
+  const clamp2 = (value, min, max) => {
+    return Math.max(min, Math.min(max, value));
+  };
+  for (const edge of edges) {
+    const va = { x: p2.x - p1.x, y: p2.y - p1.y };
+    const vb = { x: edge.end.x - edge.start.x, y: edge.end.y - edge.start.y };
+    const w = { x: p1.x - edge.start.x, y: p1.y - edge.start.y };
+    const dotAA = va.x * va.x + va.y * va.y;
+    const dotAB = va.x * vb.x + va.y * vb.y;
+    const dotAW = va.x * w.x + va.y * w.y;
+    const dotBB = vb.x * vb.x + vb.y * vb.y;
+    const dotBW = vb.x * w.x + vb.y * w.y;
+    const denominator = dotAA * dotBB - dotAB * dotAB;
+    if (Math.abs(denominator) < 1e-10) continue;
+    let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
+    let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
+    tA = clamp2(tA, 0, 1);
+    tB = clamp2(tB, 0, 1);
+    const closestOnSegment = {
+      x: p1.x + tA * va.x,
+      y: p1.y + tA * va.y
+    };
+    const closestOnEdge = {
+      x: edge.start.x + tB * vb.x,
+      y: edge.start.y + tB * vb.y
+    };
+    const dx2 = closestOnSegment.x - closestOnEdge.x;
+    const dy2 = closestOnSegment.y - closestOnEdge.y;
+    const distSquared = dx2 * dx2 + dy2 * dy2;
+    if (distSquared < minDistance) {
+      minDistance = distSquared;
+      closestPoint = {
+        x: (closestOnSegment.x + closestOnEdge.x) / 2,
+        y: (closestOnSegment.y + closestOnEdge.y) / 2
+      };
+    }
+  }
+  return closestPoint;
+};
 
 // lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegments.ts
 var getClosestPointBetweenSegments = (segmentA, segmentB) => {
@@ -557,6 +632,43 @@ var clamp = (value, min, max) => {
   return Math.max(min, Math.min(max, value));
 };
 
+// lib/check-each-pcb-trace-non-overlapping/getCollidableBounds.ts
+import { getBoundsOfPcbElements as getBoundsOfPcbElements2 } from "@tscircuit/circuit-json-util";
+var getCollidableBounds = (collidable) => {
+  if (collidable.type === "pcb_trace_segment") {
+    return {
+      minX: Math.min(collidable.x1, collidable.x2),
+      minY: Math.min(collidable.y1, collidable.y2),
+      maxX: Math.max(collidable.x1, collidable.x2),
+      maxY: Math.max(collidable.y1, collidable.y2)
+    };
+  }
+  return getBoundsOfPcbElements2([collidable]);
+};
+
+// lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
+function getPcbPortIdsConnectedToTrace(trace) {
+  const connectedPcbPorts = /* @__PURE__ */ new Set();
+  for (const segment of trace.route) {
+    if (segment.route_type === "wire") {
+      if (segment.start_pcb_port_id)
+        connectedPcbPorts.add(segment.start_pcb_port_id);
+      if (segment.end_pcb_port_id)
+        connectedPcbPorts.add(segment.end_pcb_port_id);
+    }
+  }
+  return Array.from(connectedPcbPorts);
+}
+function getPcbPortIdsConnectedToTraces(traces) {
+  const connectedPorts = /* @__PURE__ */ new Set();
+  for (const trace of traces) {
+    for (const portId of getPcbPortIdsConnectedToTrace(trace)) {
+      connectedPorts.add(portId);
+    }
+  }
+  return Array.from(connectedPorts);
+}
+
 // lib/check-each-pcb-trace-non-overlapping/getRadiusOfCircuitJsonElement.ts
 var getRadiusOfCircuitJsonElement = (obj) => {
   if (obj.type === "pcb_via") {
@@ -576,123 +688,6 @@ var getRadiusOfCircuitJsonElement = (obj) => {
   );
 };
 
-// lib/check-each-pcb-trace-non-overlapping/getClosestPointBetweenSegmentAndBounds.ts
-var getClosestPointBetweenSegmentAndBounds = (segment, bounds) => {
-  const p1 = { x: segment.x1, y: segment.y1 };
-  const p2 = { x: segment.x2, y: segment.y2 };
-  const minX = bounds.minX;
-  const minY = bounds.minY;
-  const maxX = bounds.maxX;
-  const maxY = bounds.maxY;
-  if (p1.x === p2.x && p1.y === p2.y) {
-    const closestX = Math.max(minX, Math.min(maxX, p1.x));
-    const closestY = Math.max(minY, Math.min(maxY, p1.y));
-    if (closestX === p1.x && closestY === p1.y) {
-      return { x: p1.x, y: p1.y };
-    }
-    return { x: closestX, y: closestY };
-  }
-  const dx = p2.x - p1.x;
-  const dy = p2.y - p1.y;
-  const tMinX = dx !== 0 ? (minX - p1.x) / dx : Number.NEGATIVE_INFINITY;
-  const tMaxX = dx !== 0 ? (maxX - p1.x) / dx : Number.POSITIVE_INFINITY;
-  const tMinY = dy !== 0 ? (minY - p1.y) / dy : Number.NEGATIVE_INFINITY;
-  const tMaxY = dy !== 0 ? (maxY - p1.y) / dy : Number.POSITIVE_INFINITY;
-  const tEnter = Math.max(Math.min(tMinX, tMaxX), Math.min(tMinY, tMaxY));
-  const tExit = Math.min(Math.max(tMinX, tMaxX), Math.max(tMinY, tMaxY));
-  if (tEnter <= tExit && tExit >= 0 && tEnter <= 1) {
-    const t = Math.max(0, Math.min(1, tEnter));
-    return {
-      x: p1.x + t * dx,
-      y: p1.y + t * dy
-    };
-  }
-  const closestToP1 = {
-    x: Math.max(minX, Math.min(maxX, p1.x)),
-    y: Math.max(minY, Math.min(maxY, p1.y))
-  };
-  const closestToP2 = {
-    x: Math.max(minX, Math.min(maxX, p2.x)),
-    y: Math.max(minY, Math.min(maxY, p2.y))
-  };
-  const distToP1Squared = (closestToP1.x - p1.x) ** 2 + (closestToP1.y - p1.y) ** 2;
-  const distToP2Squared = (closestToP2.x - p2.x) ** 2 + (closestToP2.y - p2.y) ** 2;
-  const edges = [
-    { start: { x: minX, y: minY }, end: { x: maxX, y: minY } },
-    // Bottom edge
-    { start: { x: maxX, y: minY }, end: { x: maxX, y: maxY } },
-    // Right edge
-    { start: { x: maxX, y: maxY }, end: { x: minX, y: maxY } },
-    // Top edge
-    { start: { x: minX, y: maxY }, end: { x: minX, y: minY } }
-    // Left edge
-  ];
-  let minDistance = Math.min(distToP1Squared, distToP2Squared);
-  let closestPoint = distToP1Squared <= distToP2Squared ? closestToP1 : closestToP2;
-  const clamp2 = (value, min, max) => {
-    return Math.max(min, Math.min(max, value));
-  };
-  for (const edge of edges) {
-    const va = { x: p2.x - p1.x, y: p2.y - p1.y };
-    const vb = { x: edge.end.x - edge.start.x, y: edge.end.y - edge.start.y };
-    const w = { x: p1.x - edge.start.x, y: p1.y - edge.start.y };
-    const dotAA = va.x * va.x + va.y * va.y;
-    const dotAB = va.x * vb.x + va.y * vb.y;
-    const dotAW = va.x * w.x + va.y * w.y;
-    const dotBB = vb.x * vb.x + vb.y * vb.y;
-    const dotBW = vb.x * w.x + vb.y * w.y;
-    const denominator = dotAA * dotBB - dotAB * dotAB;
-    if (Math.abs(denominator) < 1e-10) continue;
-    let tA = (dotAB * dotBW - dotBB * dotAW) / denominator;
-    let tB = (dotAA * dotBW - dotAB * dotAW) / denominator;
-    tA = clamp2(tA, 0, 1);
-    tB = clamp2(tB, 0, 1);
-    const closestOnSegment = {
-      x: p1.x + tA * va.x,
-      y: p1.y + tA * va.y
-    };
-    const closestOnEdge = {
-      x: edge.start.x + tB * vb.x,
-      y: edge.start.y + tB * vb.y
-    };
-    const dx2 = closestOnSegment.x - closestOnEdge.x;
-    const dy2 = closestOnSegment.y - closestOnEdge.y;
-    const distSquared = dx2 * dx2 + dy2 * dy2;
-    if (distSquared < minDistance) {
-      minDistance = distSquared;
-      closestPoint = {
-        x: (closestOnSegment.x + closestOnEdge.x) / 2,
-        y: (closestOnSegment.y + closestOnEdge.y) / 2
-      };
-    }
-  }
-  return closestPoint;
-};
-
-// lib/util/getLayersOfPcbElement.ts
-import { all_layers } from "circuit-json";
-function getLayersOfPcbElement(obj) {
-  if (obj.type === "pcb_trace_segment") {
-    return [obj.layer];
-  }
-  if (obj.type === "pcb_smtpad") {
-    return [obj.layer];
-  }
-  if (obj.type === "pcb_plated_hole") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
-  }
-  if (obj.type === "pcb_hole") {
-    return [...all_layers];
-  }
-  if (obj.type === "pcb_via") {
-    return Array.isArray(obj.layers) ? obj.layers : [...all_layers];
-  }
-  if (obj.type === "pcb_keepout") {
-    return Array.isArray(obj.layers) ? obj.layers : [];
-  }
-  return [];
-}
-
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
 function checkEachPcbTraceNonOverlapping(circuitJson, {
   connMap,
@@ -742,6 +737,12 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
     getBounds: getCollidableBounds
   });
   const getReadableName = (id) => getReadableNameForElement2(circuitJson, id);
+  const constructErrorMessage = (traceName, otherName, gap) => {
+    if (gap < 0) {
+      return `PCB trace ${traceName} overlaps with ${otherName} (accidental contact)`;
+    }
+    return `PCB trace ${traceName} is too close to ${otherName} (gap: ${gap.toFixed(3)}mm)`;
+  };
   const errorIds = /* @__PURE__ */ new Set();
   for (const segmentA of pcbTraceSegments) {
     const requiredMargin = minClearance;
@@ -775,7 +776,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${getReadableName(segmentB.pcb_trace_id)} ${gap2 < 0 ? "(accidental contact)" : `(gap: ${gap2.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            getReadableName(segmentB.pcb_trace_id),
+            gap2
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           source_trace_id: "",
           pcb_trace_error_id,
@@ -810,7 +815,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${obj.type} "${getReadableName(getPrimaryId(obj))}" ${gap2 < 0 ? "(accidental contact)" : `(gap: ${gap2.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap2
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           center: getClosestPointBetweenSegmentAndBounds(
             segmentA,
@@ -839,7 +848,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
         errors.push({
           type: "pcb_trace_error",
           error_type: "pcb_trace_error",
-          message: `PCB trace ${getReadableName(segmentA.pcb_trace_id)} overlaps with ${obj.type} "${getReadableName(getPrimaryId(obj))}" ${gap < 0 ? "(accidental contact)" : `(gap: ${gap.toFixed(3)}mm)`}`,
+          message: constructErrorMessage(
+            getReadableName(segmentA.pcb_trace_id),
+            `${obj.type} "${getReadableName(getPrimaryId(obj))}"`,
+            gap
+          ),
           pcb_trace_id: segmentA.pcb_trace_id,
           source_trace_id: "",
           pcb_trace_error_id,
@@ -2134,7 +2147,26 @@ function checkNoGroundPinDefined(circuitJson) {
 
 // lib/check-connector-accessible-orientation.ts
 import { getBoardBounds } from "@tscircuit/circuit-json-util";
+function getFacingDirectionFromInsertionDirection(component) {
+  switch (component.insertion_direction) {
+    case "from_left":
+      return "x-";
+    case "from_right":
+      return "x+";
+    case "from_front":
+      return "y+";
+    case "from_back":
+      return "y-";
+    case "from_above":
+      return null;
+    default:
+      return null;
+  }
+}
 function getFacingDirection(component) {
+  if (component.insertion_direction) {
+    return getFacingDirectionFromInsertionDirection(component);
+  }
   if (!component.center || !component.cable_insertion_center) return null;
   const dx = component.cable_insertion_center.x - component.center.x;
   const dy = component.cable_insertion_center.y - component.center.y;
@@ -2173,7 +2205,6 @@ function checkConnectorAccessibleOrientation(circuitJson) {
     (el) => el.type === "pcb_component"
   );
   for (const component of components) {
-    if (!component.cable_insertion_center) continue;
     const facingDirection = getFacingDirection(component);
     const recommendedFacingDirection = getRecommendedFacingDirection(
       component,