@tscircuit/checks 0.0.127 → 0.0.129

package/dist/index.js

@@ -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);
@@ -1706,6 +1709,9 @@ import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCirc
 import { getBoundsOfPcbElements as getBoundsOfPcbElements3 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap } from "@tscircuit/math-utils";
 function getElementLayers(elem) {
+  if (elem.type === "pcb_courtyard_circle" || elem.type === "pcb_courtyard_outline" || elem.type === "pcb_courtyard_polygon" || elem.type === "pcb_courtyard_rect") {
+    return [elem.layer];
+  }
   return getLayersOfPcbElement(elem);
 }
 function doLayersOverlap(layers1, layers2) {
@@ -1722,6 +1728,7 @@ function doPcbElementsOverlap(elem1, elem2) {
 }
 
 // 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 formatOverlapElementDescription = (circuitJson, element) => {
   if ("pcb_port_id" in element && element.pcb_port_id) {
     return getReadableNameForPort(circuitJson, element.pcb_port_id);
@@ -1736,14 +1743,14 @@ function checkPcbComponentOverlap(circuitJson) {
   const smtPads = cju4(circuitJson).pcb_smtpad.list();
   const platedHoles = cju4(circuitJson).pcb_plated_hole.list();
   const holes = cju4(circuitJson).pcb_hole.list();
+  const courtyards = circuitJson.filter(isCourtyardElement);
   const componentMap = /* @__PURE__ */ new Map();
   for (const pad of smtPads) {
     const componentId = pad.pcb_component_id || `standalone_pad_${getPrimaryId2(pad)}`;
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
-        elements: [],
-        bounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 }
+        elements: []
       });
     }
     componentMap.get(componentId).elements.push(pad);
@@ -1753,8 +1760,7 @@ function checkPcbComponentOverlap(circuitJson) {
     if (!componentMap.has(componentId)) {
       componentMap.set(componentId, {
         component_id: componentId,
-        elements: [],
-        bounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 }
+        elements: []
       });
     }
     componentMap.get(componentId).elements.push(hole);
@@ -1763,10 +1769,19 @@ function checkPcbComponentOverlap(circuitJson) {
     const componentId = `standalone_hole_${getPrimaryId2(hole)}`;
     componentMap.set(componentId, {
       component_id: componentId,
-      elements: [hole],
-      bounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 }
+      elements: [hole]
     });
   }
+  for (const courtyard of courtyards) {
+    const componentId = courtyard.pcb_component_id;
+    if (!componentMap.has(componentId)) {
+      componentMap.set(componentId, {
+        component_id: componentId,
+        elements: []
+      });
+    }
+    componentMap.get(componentId).elements.push(courtyard);
+  }
   for (const [componentId, componentData] of componentMap) {
     if (componentData.elements.length > 0) {
       componentData.bounds = getBoundsOfPcbElements4(componentData.elements);
@@ -1777,6 +1792,9 @@ function checkPcbComponentOverlap(circuitJson) {
     for (let j = i + 1; j < componentsWithElements.length; j++) {
       const comp1 = componentsWithElements[i];
       const comp2 = componentsWithElements[j];
+      if (!comp1.bounds || !comp2.bounds) {
+        continue;
+      }
       if (!doBoundsOverlap2(comp1.bounds, comp2.bounds)) {
         continue;
       }
@@ -1784,6 +1802,9 @@ function checkPcbComponentOverlap(circuitJson) {
         for (const elem2 of comp2.elements) {
           const id1 = getPrimaryId2(elem1);
           const id2 = getPrimaryId2(elem2);
+          if ((isCourtyardElement(elem1) || isCourtyardElement(elem2)) && elem1.type !== "pcb_hole" && elem2.type !== "pcb_hole") {
+            continue;
+          }
           if (elem1.type === "pcb_smtpad" && elem2.type === "pcb_smtpad" && connMap.areIdsConnected(id1, id2)) {
             continue;
           }
@@ -2626,6 +2647,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(
@@ -2716,10 +2795,13 @@ function checkTracesAreContiguous(circuitJson) {
           port.pcb_port_id
         ).replace("pcb_port", "");
         const padType = pads[0].type.replace(/pcb_/, "");
-        const errorCenter = {
-          x: (firstPoint.x + lastPoint.x) / 2,
-          y: (firstPoint.y + lastPoint.y) / 2
-        };
+        const errorCenter = getMissingConnectionErrorCenter({
+          firstPoint,
+          lastPoint,
+          port,
+          expectedPorts,
+          padMap
+        });
         errors.push({
           type: "pcb_trace_error",
           message: `Trace [${traceName}] is missing a connection to ${padType}${portName}`,