@tscircuit/schematic-trace-solver 0.0.199 → 0.0.200

package/dist/index.js

@@ -13243,6 +13243,52 @@ var getUnconnectedPins = ({
   );
   return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId));
 };
+var pathsIntersect = (firstPath, secondPath) => {
+  for (let firstIndex = 0; firstIndex < firstPath.length - 1; firstIndex++) {
+    for (let secondIndex = 0; secondIndex < secondPath.length - 1; secondIndex++) {
+      if (doSegmentsIntersect3(
+        firstPath[firstIndex],
+        firstPath[firstIndex + 1],
+        secondPath[secondIndex],
+        secondPath[secondIndex + 1]
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var connectionPairPinsAreAlreadyConnected = ({
+  connectionPair,
+  sameNetTraces
+}) => {
+  const [firstPin, secondPin] = connectionPair.pins;
+  const connectedTraceIndexes = new Set(
+    sameNetTraces.flatMap(
+      (trace, index) => trace.pinIds.includes(firstPin.pinId) ? [index] : []
+    )
+  );
+  let previousSize = -1;
+  while (connectedTraceIndexes.size !== previousSize) {
+    previousSize = connectedTraceIndexes.size;
+    for (let traceIndex = 0; traceIndex < sameNetTraces.length; traceIndex++) {
+      if (connectedTraceIndexes.has(traceIndex)) continue;
+      const trace = sameNetTraces[traceIndex];
+      const connectsToComponent = [...connectedTraceIndexes].some(
+        (connectedTraceIndex) => {
+          const connectedTrace = sameNetTraces[connectedTraceIndex];
+          return trace.pinIds.some(
+            (pinId) => connectedTrace.pinIds.includes(pinId)
+          ) || pathsIntersect(trace.tracePath, connectedTrace.tracePath);
+        }
+      );
+      if (connectsToComponent) connectedTraceIndexes.add(traceIndex);
+    }
+  }
+  return [...connectedTraceIndexes].some(
+    (traceIndex) => sameNetTraces[traceIndex].pinIds.includes(secondPin.pinId)
+  );
+};
 var getJunctionCandidates = ({
   connectionPair,
   sameNetTraces,
@@ -13507,6 +13553,12 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
     const sameNetTraces = existingTraces.filter(
       (trace) => trace.globalConnNetId === connectionPair.globalConnNetId
     );
+    if (connectionPairPinsAreAlreadyConnected({
+      connectionPair,
+      sameNetTraces
+    })) {
+      return;
+    }
     const junctionCandidates = getJunctionCandidates({
       connectionPair,
       sameNetTraces,
@@ -14519,7 +14571,7 @@ var getAlignedAttachedLabelConnectorPath = ({
   const reverseCandidate = findCandidate([...forwardPath].reverse());
   return reverseCandidate ? reverseCandidate.reverse() : null;
 };
-var pathsIntersect = (firstPath, secondPath) => {
+var pathsIntersect2 = (firstPath, secondPath) => {
   if (firstPath.some((point) => tracePathContainsPoint(secondPath, point)) || secondPath.some((point) => tracePathContainsPoint(firstPath, point))) {
     return true;
   }
@@ -14546,7 +14598,7 @@ var preserveAttachedTraceJunctions = ({
     (trace) => trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace
   );
   for (const connector of traces) {
-    if (connector.mspPairId === originalTrace.mspPairId || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
+    if (connector.mspPairId === originalTrace.mspPairId || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect2(originalTrace.tracePath, connector.tracePath) || pathsIntersect2(candidateTrace.tracePath, connector.tracePath)) {
       continue;
     }
     const endpointIndex = [0, connector.tracePath.length - 1].find(
@@ -14579,7 +14631,7 @@ var preserveAttachedTraceJunctions = ({
         (point, index) => index === endpointIndex ? movedJunction : point
       )
     };
-    if (!pathsIntersect(candidateTrace.tracePath, movedConnector.tracePath)) {
+    if (!pathsIntersect2(candidateTrace.tracePath, movedConnector.tracePath)) {
       return null;
     }
     outputTraces = outputTraces.map(

package/lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts

@@ -204,6 +204,67 @@ const getUnconnectedPins = ({
   return connectionPair.pins.filter((pin) => !connectedPinIds.has(pin.pinId))
 }
 
+const pathsIntersect = (firstPath: Point[], secondPath: Point[]): boolean => {
+  for (let firstIndex = 0; firstIndex < firstPath.length - 1; firstIndex++) {
+    for (
+      let secondIndex = 0;
+      secondIndex < secondPath.length - 1;
+      secondIndex++
+    ) {
+      if (
+        doSegmentsIntersect(
+          firstPath[firstIndex]!,
+          firstPath[firstIndex + 1]!,
+          secondPath[secondIndex]!,
+          secondPath[secondIndex + 1]!,
+        )
+      ) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+const connectionPairPinsAreAlreadyConnected = ({
+  connectionPair,
+  sameNetTraces,
+}: {
+  connectionPair: MspConnectionPair
+  sameNetTraces: SolvedTracePath[]
+}): boolean => {
+  const [firstPin, secondPin] = connectionPair.pins
+  const connectedTraceIndexes = new Set(
+    sameNetTraces.flatMap((trace, index) =>
+      trace.pinIds.includes(firstPin.pinId) ? [index] : [],
+    ),
+  )
+
+  let previousSize = -1
+  while (connectedTraceIndexes.size !== previousSize) {
+    previousSize = connectedTraceIndexes.size
+    for (let traceIndex = 0; traceIndex < sameNetTraces.length; traceIndex++) {
+      if (connectedTraceIndexes.has(traceIndex)) continue
+      const trace = sameNetTraces[traceIndex]!
+      const connectsToComponent = [...connectedTraceIndexes].some(
+        (connectedTraceIndex) => {
+          const connectedTrace = sameNetTraces[connectedTraceIndex]!
+          return (
+            trace.pinIds.some((pinId) =>
+              connectedTrace.pinIds.includes(pinId),
+            ) || pathsIntersect(trace.tracePath, connectedTrace.tracePath)
+          )
+        },
+      )
+      if (connectsToComponent) connectedTraceIndexes.add(traceIndex)
+    }
+  }
+
+  return [...connectedTraceIndexes].some((traceIndex) =>
+    sameNetTraces[traceIndex]!.pinIds.includes(secondPin.pinId),
+  )
+}
+
 const getJunctionCandidates = ({
   connectionPair,
   sameNetTraces,
@@ -552,6 +613,14 @@ export class UnroutedTraceRecoverySolver extends BaseSolver {
     const sameNetTraces = existingTraces.filter(
       (trace) => trace.globalConnNetId === connectionPair.globalConnNetId,
     )
+    if (
+      connectionPairPinsAreAlreadyConnected({
+        connectionPair,
+        sameNetTraces,
+      })
+    ) {
+      return
+    }
     const junctionCandidates = getJunctionCandidates({
       connectionPair,
       sameNetTraces,

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.199",
+  "version": "0.0.200",
   "type": "module",
   "scripts": {
     "start": "cosmos",