@tscircuit/checks 0.0.168 → 0.0.170

package/dist/index.js

@@ -332,7 +332,10 @@ var addStartAndEndPortIdsIfMissing = (soup) => {
 };
 
 // lib/check-each-pcb-port-connected-to-pcb-trace.ts
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import {
+  getFullConnectivityMapFromCircuitJson,
+  PcbConnectivityMap
+} from "circuit-json-to-connectivity-map";
 
 // lib/util/get-readable-names.ts
 import {
@@ -470,14 +473,41 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
   const pcbPorts = circuitJson.filter(
     (item) => item.type === "pcb_port"
   );
+  const sourceNets = circuitJson.filter(
+    (item) => item.type === "source_net"
+  );
   const errors = [];
   const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson);
+  const pcbConnectivityMap = new PcbConnectivityMap(circuitJson);
   const sourcePortToPcbPort = /* @__PURE__ */ new Map();
   for (const pcbPort of pcbPorts) {
     sourcePortToPcbPort.set(pcbPort.source_port_id, pcbPort);
   }
+  const sourceNetNameById = new Map(
+    sourceNets.map((sourceNet) => [sourceNet.source_net_id, sourceNet.name])
+  );
   for (const sourceTrace of sourceTraces) {
     const connectedSourcePortIds = sourceTrace.connected_source_port_ids;
+    if (connectedSourcePortIds.length === 1 && sourceTrace.connected_source_net_ids.length > 0) {
+      const pcbPort = sourcePortToPcbPort.get(connectedSourcePortIds[0]);
+      if (!pcbPort) continue;
+      const connectedPcbTraces = pcbConnectivityMap.getAllTracesConnectedToPort(
+        pcbPort.pcb_port_id
+      );
+      if (connectedPcbTraces.length === 0) {
+        const connectedNetNames = sourceTrace.connected_source_net_ids.map((sourceNetId) => sourceNetNameById.get(sourceNetId)).filter((name) => Boolean(name));
+        const netDescription = connectedNetNames.length > 0 ? `net [${connectedNetNames.join(", ")}]` : "its connected net";
+        errors.push({
+          type: "pcb_port_not_connected_error",
+          message: `Port [${getReadableNameForPort(circuitJson, pcbPort.pcb_port_id)}] is not connected to ${netDescription} by a PCB trace.`,
+          error_type: "pcb_port_not_connected_error",
+          pcb_port_ids: [pcbPort.pcb_port_id],
+          pcb_component_ids: pcbPort.pcb_component_id ? [pcbPort.pcb_component_id] : [],
+          pcb_port_not_connected_error_id: `pcb_port_not_connected_error_trace_${sourceTrace.source_trace_id}`
+        });
+      }
+      continue;
+    }
     if (connectedSourcePortIds.length < 2) {
       continue;
     }
@@ -2552,7 +2582,10 @@ import {
   getReadableNameForPcbPort as getReadableNameForPcbPort2,
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
-import { PcbConnectivityMap } from "circuit-json-to-connectivity-map";
+import { PcbConnectivityMap as PcbConnectivityMap2 } from "circuit-json-to-connectivity-map";
+function routePointTouchesPad(point, pad) {
+  return point.route_type === "wire" && getLayersOfPcbElement(pad).includes(point.layer) && isPointInPad(point, pad);
+}
 function getRoutePointCenter(point) {
   if (point.route_type === "through_pad") {
     return {
@@ -2563,15 +2596,12 @@ function getRoutePointCenter(point) {
   return { x: point.x, y: point.y };
 }
 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;
+    return expectedPads?.some((pad) => routePointTouchesPad(point, pad)) ?? false;
   });
 }
 function getMissingConnectionErrorCenter({
@@ -2640,7 +2670,7 @@ function checkTracesAreContiguous(circuitJson) {
     (el) => el.type === "pcb_plated_hole"
   );
   const padMap = /* @__PURE__ */ new Map();
-  const pcbConnectivityMap = new PcbConnectivityMap(circuitJson);
+  const pcbConnectivityMap = new PcbConnectivityMap2(circuitJson);
   const checkedSourceTraceIds = /* @__PURE__ */ new Set();
   for (const pad of pcbSmtPads) {
     if (pad.pcb_port_id) {
@@ -2655,6 +2685,65 @@ function checkTracesAreContiguous(circuitJson) {
       ]);
     }
   }
+  const touchedPortIdsByTraceId = /* @__PURE__ */ new Map();
+  const traceIdsByTouchedPortId = /* @__PURE__ */ new Map();
+  for (const trace of pcbTraces) {
+    const touchedPortIds = /* @__PURE__ */ new Set();
+    const firstPoint = trace.route[0];
+    const lastPoint = trace.route.at(-1);
+    for (const point of [firstPoint, lastPoint]) {
+      if (!point) continue;
+      for (const [pcbPortId, pads] of padMap) {
+        if (pads.some((pad) => routePointTouchesPad(point, pad))) {
+          touchedPortIds.add(pcbPortId);
+        }
+      }
+    }
+    touchedPortIdsByTraceId.set(trace.pcb_trace_id, touchedPortIds);
+    for (const pcbPortId of touchedPortIds) {
+      const traceIds = traceIdsByTouchedPortId.get(pcbPortId) ?? /* @__PURE__ */ new Set();
+      traceIds.add(trace.pcb_trace_id);
+      traceIdsByTouchedPortId.set(pcbPortId, traceIds);
+    }
+  }
+  const physicallyConnectedTracesByTraceId = /* @__PURE__ */ new Map();
+  const getPhysicallyConnectedTraces = (startTrace) => {
+    const cached = physicallyConnectedTracesByTraceId.get(
+      startTrace.pcb_trace_id
+    );
+    if (cached) return cached;
+    const connectedTraceIds = /* @__PURE__ */ new Set();
+    const pendingTraceIds = [startTrace.pcb_trace_id];
+    while (pendingTraceIds.length > 0) {
+      const traceId = pendingTraceIds.pop();
+      if (connectedTraceIds.has(traceId)) continue;
+      connectedTraceIds.add(traceId);
+      for (const connectedTrace of pcbConnectivityMap.getAllTracesConnectedToTrace(
+        traceId
+      )) {
+        if (!connectedTraceIds.has(connectedTrace.pcb_trace_id)) {
+          pendingTraceIds.push(connectedTrace.pcb_trace_id);
+        }
+      }
+      for (const pcbPortId of touchedPortIdsByTraceId.get(traceId) ?? []) {
+        for (const touchingTraceId of traceIdsByTouchedPortId.get(pcbPortId) ?? []) {
+          if (!connectedTraceIds.has(touchingTraceId)) {
+            pendingTraceIds.push(touchingTraceId);
+          }
+        }
+      }
+    }
+    const connectedTraces = pcbTraces.filter(
+      (trace) => connectedTraceIds.has(trace.pcb_trace_id)
+    );
+    for (const trace of connectedTraces) {
+      physicallyConnectedTracesByTraceId.set(
+        trace.pcb_trace_id,
+        connectedTraces
+      );
+    }
+    return connectedTraces;
+  };
   for (const trace of pcbTraces) {
     if (trace.route.length === 0) continue;
     const firstPoint = trace.route[0];
@@ -2706,39 +2795,17 @@ function checkTracesAreContiguous(circuitJson) {
       if (!port.pcb_port_id) continue;
       const pads = padMap.get(port.pcb_port_id);
       if (!pads?.length) continue;
-      let isConnectedByRoutedSourceTrace = false;
-      const candidateTraces = [
-        ...pcbConnectivityMap.getAllTracesConnectedToTrace(trace.pcb_trace_id),
-        ...pcbTraces.filter(
-          (candidateTrace) => candidateTrace.source_trace_id === sourceTrace?.source_trace_id
-        )
-      ];
-      for (const candidateTrace of candidateTraces) {
-        if (candidateTrace.pcb_trace_id === trace.pcb_trace_id) continue;
-        if (!candidateTrace.source_trace_id) continue;
-        const candidateSourceTrace = sourceTraces.find(
-          (st) => st.source_trace_id === candidateTrace.source_trace_id
-        );
-        if (!sourceTrace || candidateTrace.source_trace_id !== sourceTrace.source_trace_id && !candidateSourceTrace?.connected_source_port_ids.includes(
-          port.source_port_id
-        )) {
-          continue;
-        }
-        const candidateFirstPoint = candidateTrace.route[0];
-        const candidateLastPoint = candidateTrace.route.at(-1);
-        if (getPcbPortIdsConnectedToTrace(candidateTrace).includes(
-          port.pcb_port_id
-        ) || candidateFirstPoint?.route_type === "wire" && pads.some((pad) => isPointInPad(candidateFirstPoint, pad)) || candidateLastPoint?.route_type === "wire" && pads.some((pad) => isPointInPad(candidateLastPoint, pad))) {
-          isConnectedByRoutedSourceTrace = true;
-          break;
-        }
-      }
+      const isConnectedByRoutedSourceTrace = getPhysicallyConnectedTraces(
+        trace
+      ).some(
+        (candidateTrace) => touchedPortIdsByTraceId.get(candidateTrace.pcb_trace_id)?.has(port.pcb_port_id)
+      );
       if (isConnectedByRoutedSourceTrace) continue;
-      const isFirstPointConnected = firstPoint.route_type === "wire" && pads.some(
-        (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
+      const isFirstPointConnected = pads.some(
+        (pad) => routePointTouchesPad(firstPoint, pad)
       );
-      const isLastPointConnected = lastPoint.route_type === "wire" && pads.some(
-        (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
+      const isLastPointConnected = pads.some(
+        (pad) => routePointTouchesPad(lastPoint, pad)
       );
       if (!isFirstPointConnected && !isLastPointConnected) {
         const portName = getReadableNameForPcbPort2(
@@ -2771,14 +2838,10 @@ function checkTracesAreContiguous(circuitJson) {
       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 pads of padMap.values()) {
-        if (firstPoint.route_type === "wire" && pads.some(
-          (pad) => isPointInPad({ x: firstPoint.x, y: firstPoint.y }, pad)
-        )) {
+        if (pads.some((pad) => routePointTouchesPad(firstPoint, pad))) {
           firstConnectsToAnyPad = true;
         }
-        if (lastPoint.route_type === "wire" && pads.some(
-          (pad) => isPointInPad({ x: lastPoint.x, y: lastPoint.y }, pad)
-        )) {
+        if (pads.some((pad) => routePointTouchesPad(lastPoint, pad))) {
           lastConnectsToAnyPad = true;
         }
       }