@tscircuit/checks 0.0.169 → 0.0.170

package/dist/index.js

@@ -2583,6 +2583,9 @@ import {
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
 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 {
@@ -2593,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({
@@ -2685,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];
@@ -2736,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(
@@ -2801,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;
         }
       }