@tscircuit/schematic-trace-solver 0.0.29 → 0.0.30

package/dist/index.js

@@ -1494,10 +1494,11 @@ function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex)
     const pts = solved.tracePath;
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue;
-      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds)) return true;
+      if (segmentIntersectsRect(pts[i], pts[i + 1], bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i };
     }
   }
-  return false;
+  return { hasIntersection: false };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts
@@ -1582,14 +1583,16 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     };
   }
   let pin = null;
+  let pinFacingDirection = null;
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId);
     if (p) {
       pin = { x: p.x, y: p.y };
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip);
       break;
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -1601,21 +1604,21 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
   const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
   const testedCandidates = [];
   for (const orientation of orientations) {
-    const { width, height } = getDimsForOrientation(orientation);
-    const baseCenter = getCenterFromAnchor(anchor, orientation, width, height);
-    const outward = outwardOf(orientation);
-    const offset = 1e-3;
+    const { width: width2, height: height2 } = getDimsForOrientation(orientation);
+    const baseCenter2 = getCenterFromAnchor(anchor, orientation, width2, height2);
+    const outward2 = outwardOf(orientation);
+    const offset2 = 1e-3;
     const center = {
-      x: baseCenter.x + outward.x * offset,
-      y: baseCenter.y + outward.y * offset
+      x: baseCenter2.x + outward2.x * offset2,
+      y: baseCenter2.y + outward2.y * offset2
     };
-    const bounds = getRectBounds(center, width, height);
+    const bounds = getRectBounds(center, width2, height2);
     const chips = chipObstacleSpatialIndex.getChipsInBounds(bounds);
     if (chips.length > 0) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1624,16 +1627,17 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       });
       continue;
     }
-    if (rectIntersectsAnyTrace(
+    const traceIntersectionResult = rectIntersectsAnyTrace(
       bounds,
       inputTraceMap,
       "",
       -1
-    )) {
+    );
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
-        width,
-        height,
+        width: width2,
+        height: height2,
         bounds,
         anchor,
         orientation,
@@ -1644,8 +1648,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     }
     testedCandidates.push({
       center,
-      width,
-      height,
+      width: width2,
+      height: height2,
       bounds,
       anchor,
       orientation,
@@ -1660,17 +1664,39 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       pinIds: [pinId],
       orientation,
       anchorPoint: anchor,
-      width,
-      height,
+      width: width2,
+      height: height2,
       center
     };
     return { placement, testedCandidates };
   }
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions"
+  const fallbackOrientation = pinFacingDirection;
+  const { width, height } = getDimsForOrientation(fallbackOrientation);
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height
+  );
+  const outward = outwardOf(fallbackOrientation);
+  const offset = 1e-3;
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset
+  };
+  const fallbackPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: void 0,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter
   };
+  return { placement: fallbackPlacement, testedCandidates };
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts
@@ -1686,12 +1712,11 @@ function visualizeSingleNetLabelPlacementSolver(solver) {
   const groupStroke = getColorFromString(groupId, 0.9);
   const groupFill = getColorFromString(groupId, 0.5);
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue;
     const isHost = host ? trace.mspPairId === host.mspPairId : false;
     graphics.lines.push({
-      points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? void 0 : "4 2"
+      points: trace.tracePath
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     });
   }
   for (const c of solver.testedCandidates) {
@@ -1863,12 +1888,13 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               });
               continue;
             }
-            if (rectIntersectsAnyTrace(
+            const traceIntersectionResult = rectIntersectsAnyTrace(
               bounds,
               this.inputTraceMap,
               curr.mspPairId,
               si
-            )) {
+            );
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -261,14 +261,13 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
             }
 
             // Trace collision check (ignore the host segment)
-            if (
-              rectIntersectsAnyTrace(
-                bounds,
-                this.inputTraceMap,
-                curr.mspPairId,
-                si,
-              )
-            ) {
+            const traceIntersectionResult = rectIntersectsAnyTrace(
+              bounds,
+              this.inputTraceMap,
+              curr.mspPairId,
+              si,
+            )
+            if (traceIntersectionResult.hasIntersection) {
               this.testedCandidates.push({
                 center: testCenter,
                 width,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver_visualize.ts

@@ -21,12 +21,11 @@ export function visualizeSingleNetLabelPlacementSolver(
   const groupFill = getColorFromString(groupId, 0.5)
 
   for (const trace of Object.values(solver.inputTraceMap)) {
-    if (trace.globalConnNetId !== groupId) continue
     const isHost = host ? trace.mspPairId === host.mspPairId : false
     graphics.lines!.push({
       points: trace.tracePath,
-      strokeColor: isHost ? groupStroke : groupFill,
-      strokeDash: isHost ? undefined : "4 2",
+      // strokeColor: isHost ? groupStroke : groupFill,
+      // strokeDash: isHost ? undefined : "4 2",
     } as any)
   }
 

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts

@@ -33,13 +33,20 @@ export function rectIntersectsAnyTrace(
   inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>,
   hostPathId?: MspConnectionPairId,
   hostSegIndex?: number,
-): boolean {
+):
+  | {
+      hasIntersection: true
+      mspPairId: MspConnectionPairId
+      segIndex: number
+    }
+  | { hasIntersection: false } {
   for (const [pairId, solved] of Object.entries(inputTraceMap)) {
     const pts = solved.tracePath
     for (let i = 0; i < pts.length - 1; i++) {
       if (pairId === hostPathId && i === hostSegIndex) continue
-      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds)) return true
+      if (segmentIntersectsRect(pts[i]!, pts[i + 1]!, bounds))
+        return { hasIntersection: true, mspPairId: pairId, segIndex: i }
     }
   }
-  return false
+  return { hasIntersection: false }
 }

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -3,6 +3,7 @@ import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/Ms
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { FacingDirection } from "lib/utils/dir"
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
 import type {
   NetLabelPlacement,
   OverlappingSameNetTraceGroup,
@@ -51,16 +52,18 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
   }
 
-  // Find pin coordinates
+  // Find pin coordinates and facing direction
   let pin: { x: number; y: number } | null = null
+  let pinFacingDirection: FacingDirection | null = null
   for (const chip of inputProblem.chips) {
     const p = chip.pins.find((pp) => pp.pinId === pinId)
     if (p) {
       pin = { x: p.x, y: p.y }
+      pinFacingDirection = p._facingDirection || getPinDirection(p, chip)
       break
     }
   }
-  if (!pin) {
+  if (!pin || !pinFacingDirection) {
     return {
       placement: null,
       testedCandidates: [],
@@ -123,14 +126,13 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     }
 
     // Trace collision check
-    if (
-      rectIntersectsAnyTrace(
-        bounds,
-        inputTraceMap,
-        "" as MspConnectionPairId,
-        -1,
-      )
-    ) {
+    const traceIntersectionResult = rectIntersectsAnyTrace(
+      bounds,
+      inputTraceMap,
+      "" as MspConnectionPairId,
+      -1,
+    )
+    if (traceIntersectionResult.hasIntersection) {
       testedCandidates.push({
         center,
         width,
@@ -172,9 +174,34 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     return { placement, testedCandidates }
   }
 
-  return {
-    placement: null,
-    testedCandidates,
-    error: "Could not place net label at port without collisions",
+  // If no valid placements found, return placement using pin's facing direction
+  const fallbackOrientation = pinFacingDirection
+  const { width, height } = getDimsForOrientation(fallbackOrientation)
+  const baseCenter = getCenterFromAnchor(
+    anchor,
+    fallbackOrientation,
+    width,
+    height,
+  )
+  const outward = outwardOf(fallbackOrientation)
+  const offset = 1e-3
+  const fallbackCenter = {
+    x: baseCenter.x + outward.x * offset,
+    y: baseCenter.y + outward.y * offset,
   }
+
+  const fallbackPlacement: NetLabelPlacement = {
+    globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
+    dcConnNetId: undefined,
+    netId: overlappingSameNetTraceGroup.netId,
+    mspConnectionPairIds: [],
+    pinIds: [pinId],
+    orientation: fallbackOrientation,
+    anchorPoint: anchor,
+    width,
+    height,
+    center: fallbackCenter,
+  }
+
+  return { placement: fallbackPlacement, testedCandidates }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/examples/example14.test.tsx

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
 import { inputProblem } from "site/examples/example14.page"
-import "tests/fixtures/matcher"
 
 test.skip("example14 - should fail with net label placement collision error", () => {
   const solver = new SchematicTracePipelineSolver(inputProblem)

package/tests/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.test.ts

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { SingleNetLabelPlacementSolver } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver"
 import { input } from "site/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.page"
-import "tests/fixtures/matcher"
 
 test("SingleNetLabelPlacementSolver01 issue reproduction (should pass)", () => {
   const solver = new SingleNetLabelPlacementSolver(input as any)
@@ -9,5 +8,5 @@ test("SingleNetLabelPlacementSolver01 issue reproduction (should pass)", () => {
   solver.solve()
 
   // TODO: Fix the test
-  // expect(solver.solved).toBe(true)
+  expect(solver.solved).toBe(true)
 })