@tscircuit/checks 0.0.126 → 0.0.128

package/dist/index.js

@@ -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
@@ -811,14 +811,17 @@ var getCollidableBounds = (collidable) => {
 };
 
 // lib/check-each-pcb-trace-non-overlapping/getPcbPortIdsConnectedToTraces.ts
+function getPcbPortIdsConnectedToRoutePoint(routePoint) {
+  if (routePoint.route_type !== "wire") return [];
+  return [routePoint.start_pcb_port_id, routePoint.end_pcb_port_id].filter(
+    (portId) => Boolean(portId)
+  );
+}
 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);
+    for (const portId of getPcbPortIdsConnectedToRoutePoint(segment)) {
+      connectedPcbPorts.add(portId);
     }
   }
   return Array.from(connectedPcbPorts);
@@ -966,12 +969,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;
@@ -1003,11 +1006,11 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
       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(
+        const { distance: distance3, center } = getSegmentToPolygonClearance(
           segmentA,
           padOutline
         );
-        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;
@@ -1660,14 +1663,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 = segmentToSegmentMinDistance3(
+        const distance3 = segmentToSegmentMinDistance3(
           segmentStart,
           segmentEnd,
           edgeStart,
           edgeEnd
         );
-        if (distance4 < minDistance) {
-          minDistance = distance4;
+        if (distance3 < minDistance) {
+          minDistance = distance3;
         }
       }
       const minimumDistance = traceWidth / 2 + margin;
@@ -2545,13 +2548,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;
@@ -2583,10 +2595,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;
@@ -2606,6 +2629,64 @@ import {
   getReadableNameForPcbPort as getReadableNameForPcbPort2,
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
+function routePointConnectsToAnotherExpectedPort(point, expectedPorts, missingPcbPortId, padMap) {
+  if (point.route_type !== "wire") return false;
+  return expectedPorts.some((expectedPort) => {
+    if (!expectedPort.pcb_port_id || expectedPort.pcb_port_id === missingPcbPortId) {
+      return false;
+    }
+    const expectedPads = padMap.get(expectedPort.pcb_port_id);
+    return expectedPads?.some(
+      (pad) => isPointInPad({ x: point.x, y: point.y }, pad)
+    ) ?? false;
+  });
+}
+function getMissingConnectionErrorCenter({
+  firstPoint,
+  lastPoint,
+  port,
+  expectedPorts,
+  padMap
+}) {
+  let errorLocation;
+  const firstWirePoint = firstPoint.route_type === "wire" ? firstPoint : void 0;
+  const lastWirePoint = lastPoint.route_type === "wire" ? lastPoint : void 0;
+  const firstWirePointReferencesPort = getPcbPortIdsConnectedToRoutePoint(
+    firstPoint
+  ).includes(port.pcb_port_id);
+  const lastWirePointReferencesPort = getPcbPortIdsConnectedToRoutePoint(
+    lastPoint
+  ).includes(port.pcb_port_id);
+  if (firstWirePointReferencesPort && firstWirePoint) {
+    errorLocation = firstWirePoint;
+  } else if (lastWirePointReferencesPort && lastWirePoint) {
+    errorLocation = lastWirePoint;
+  } else if (routePointConnectsToAnotherExpectedPort(
+    firstPoint,
+    expectedPorts,
+    port.pcb_port_id,
+    padMap
+  ) && lastWirePoint) {
+    errorLocation = lastWirePoint;
+  } else if (routePointConnectsToAnotherExpectedPort(
+    lastPoint,
+    expectedPorts,
+    port.pcb_port_id,
+    padMap
+  ) && firstWirePoint) {
+    errorLocation = firstWirePoint;
+  } else if (firstWirePoint && lastWirePoint) {
+    errorLocation = distance2(firstWirePoint, port) <= distance2(lastWirePoint, port) ? firstWirePoint : lastWirePoint;
+  } else if (firstWirePoint) {
+    errorLocation = firstWirePoint;
+  } else if (lastWirePoint) {
+    errorLocation = lastWirePoint;
+  }
+  return errorLocation ? { x: errorLocation.x, y: errorLocation.y } : {
+    x: (firstPoint.x + lastPoint.x) / 2,
+    y: (firstPoint.y + lastPoint.y) / 2
+  };
+}
 function checkTracesAreContiguous(circuitJson) {
   const errors = [];
   const pcbPorts = circuitJson.filter(
@@ -2626,12 +2707,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) {
@@ -2679,20 +2763,27 @@ 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 errorCenter = {
-          x: (firstPoint.x + lastPoint.x) / 2,
-          y: (firstPoint.y + lastPoint.y) / 2
-        };
+        const padType = pads[0].type.replace(/pcb_/, "");
+        const errorCenter = getMissingConnectionErrorCenter({
+          firstPoint,
+          lastPoint,
+          port,
+          expectedPorts,
+          padMap
+        });
         errors.push({
           type: "pcb_trace_error",
           message: `Trace [${traceName}] is missing a connection to ${padType}${portName}`,
@@ -2710,11 +2801,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;
         }
       }