@tscircuit/schematic-trace-solver 0.0.159 → 0.0.161

package/tests/solvers/InlineNetLabelSolver/multi-pin-connected-components.test.ts

@@ -0,0 +1,252 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("a multi-pin net labels routed and disconnected components inline", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          {
+            pinId: "J1.1",
+            x: -0.5,
+            y: 0.2,
+            _facingDirection: "x-",
+          },
+          {
+            pinId: "J1.2",
+            x: -0.5,
+            y: -0.2,
+            _facingDirection: "x-",
+          },
+        ],
+      },
+      {
+        chipId: "U1",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          {
+            pinId: "U1.1",
+            x: 2.5,
+            y: 0,
+            _facingDirection: "x+",
+          },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "MOTOR",
+        pinIds: ["J1.1", "J1.2", "U1.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { MOTOR: ["x-", "x+"] },
+  }
+  const shortConnectorTrace: SolvedTracePath = {
+    mspPairId: "J1.1-J1.2",
+    mspConnectionPairIds: ["J1.1-J1.2"],
+    dcConnNetId: "MOTOR",
+    globalConnNetId: "MOTOR",
+    userNetId: "MOTOR",
+    pins: [
+      { pinId: "J1.1", chipId: "J1", x: -0.5, y: 0.2 },
+      { pinId: "J1.2", chipId: "J1", x: -0.5, y: -0.2 },
+    ],
+    pinIds: ["J1.1", "J1.2"],
+    tracePath: [
+      { x: -0.5, y: 0.2 },
+      { x: -0.8, y: 0.2 },
+      { x: -0.8, y: -0.2 },
+      { x: -0.5, y: -0.2 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [shortConnectorTrace],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(3)
+  expect(
+    output.inlineNetLabelPlacements.every(
+      (placement) => placement.stubTracePath !== undefined,
+    ),
+  ).toBe(true)
+  expect(output.traces).toHaveLength(0)
+  expect(output.netLabelPlacements).toHaveLength(0)
+})
+
+test("a short routed component is retained when replacing it would strand an intermediate pin", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          { pinId: "J1.1", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "J1.2", x: -0.5, y: -0.2, _facingDirection: "x-" },
+        ],
+      },
+      {
+        chipId: "U1",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: 2.5, y: 0, _facingDirection: "x+" }],
+      },
+    ],
+    directConnections: [{ pinIds: ["J1.1", "J1.2"] }],
+    netConnections: [
+      {
+        netId: "MOTOR",
+        pinIds: ["J1.1", "U1.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { MOTOR: ["x-", "x+"] },
+  }
+  const shortTrace: SolvedTracePath = {
+    mspPairId: "J1.1-J1.2",
+    mspConnectionPairIds: ["J1.1-J1.2"],
+    dcConnNetId: "MOTOR",
+    globalConnNetId: "MOTOR",
+    userNetId: "MOTOR",
+    pins: [
+      { pinId: "J1.1", chipId: "J1", x: -0.5, y: 0.2 },
+      { pinId: "J1.2", chipId: "J1", x: -0.5, y: -0.2 },
+    ],
+    pinIds: ["J1.1", "J1.2"],
+    tracePath: [
+      { x: -0.5, y: 0.2 },
+      { x: -0.8, y: 0.2 },
+      { x: -0.8, y: -0.2 },
+      { x: -0.5, y: -0.2 },
+    ],
+  }
+  const anchoredLabels: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "MOTOR",
+      netId: "MOTOR",
+      mspConnectionPairIds: ["J1.1-J1.2"],
+      pinIds: ["J1.1", "J1.2"],
+      orientation: "x-",
+      anchorPoint: { x: -0.8, y: 0 },
+      center: { x: -1.2, y: 0 },
+      width: 0.6,
+      height: 0.12,
+    },
+    {
+      globalConnNetId: "MOTOR",
+      netId: "MOTOR",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.1"],
+      orientation: "x+",
+      anchorPoint: { x: 2.5, y: 0 },
+      center: { x: 2.9, y: 0 },
+      width: 0.6,
+      height: 0.12,
+    },
+  ]
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [shortTrace],
+    netLabelPlacements: anchoredLabels,
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(0)
+  expect(output.traces).toEqual([shortTrace])
+  expect(output.netLabelPlacements).toEqual(anchoredLabels)
+})
+
+test("a generated anchored-label connector becomes an inline terminal stub", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: -0.5, y: 0, _facingDirection: "x-" }],
+      },
+      {
+        chipId: "U2",
+        center: { x: 3, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U2.1", x: 2.5, y: 0, _facingDirection: "x-" }],
+      },
+      {
+        chipId: "U3",
+        center: { x: 6, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U3.1", x: 5.5, y: 0, _facingDirection: "x-" }],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "SIGNAL",
+        pinIds: ["U1.1", "U2.1", "U3.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.6,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    availableNetLabelOrientations: { SIGNAL: ["x-"] },
+  }
+  const generatedLabelConnector: SolvedTracePath = {
+    mspPairId: "available-net-orientation-0-SIGNAL",
+    mspConnectionPairIds: ["available-net-orientation-0-SIGNAL"],
+    dcConnNetId: "SIGNAL",
+    globalConnNetId: "SIGNAL",
+    userNetId: "SIGNAL",
+    pins: [
+      { pinId: "U1.1", chipId: "U1", x: -0.5, y: 0 },
+      { pinId: "U1.1", chipId: "U1", x: -0.5, y: 0 },
+    ],
+    pinIds: ["U1.1"],
+    tracePath: [
+      { x: -0.5, y: 0 },
+      { x: -1.5, y: 0 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [generatedLabelConnector],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  const output = solver.getOutput()
+  expect(output.inlineNetLabelPlacements).toHaveLength(3)
+  expect(
+    output.inlineNetLabelPlacements.every(
+      (placement) => placement.stubTracePath !== undefined,
+    ),
+  ).toBe(true)
+  expect(output.traces).toHaveLength(0)
+})

package/tests/solvers/InlineNetLabelSolver/opposite-side-placement.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test"
+import { InlineNetLabelSolver } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("an inline label tries the opposite side when the preferred side is blocked", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: -2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U1.1", x: -1.5, y: 0 }],
+      },
+      {
+        chipId: "U2",
+        center: { x: 2, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [{ pinId: "U2.1", x: 1.5, y: 0 }],
+      },
+    ],
+    directConnections: [
+      {
+        netId: "SIGNAL",
+        pinIds: ["U1.1", "U2.1"],
+        allowInlineNetLabel: true,
+        inlineNetLabelWidth: 0.8,
+        inlineNetLabelHeight: 0.12,
+      },
+    ],
+    netConnections: [],
+    textBoxes: [
+      {
+        center: { x: 0, y: 0.11 },
+        width: 3,
+        height: 0.12,
+        text: "preferred-side obstacle",
+      },
+    ],
+    availableNetLabelOrientations: { SIGNAL: ["x-", "x+"] },
+  }
+  const trace: SolvedTracePath = {
+    mspPairId: "U1.1-U2.1",
+    mspConnectionPairIds: ["U1.1-U2.1"],
+    dcConnNetId: "SIGNAL",
+    globalConnNetId: "SIGNAL",
+    userNetId: "SIGNAL",
+    pins: [
+      { pinId: "U1.1", chipId: "U1", x: -1.5, y: 0 },
+      { pinId: "U2.1", chipId: "U2", x: 1.5, y: 0 },
+    ],
+    pinIds: ["U1.1", "U2.1"],
+    tracePath: [
+      { x: -1.5, y: 0 },
+      { x: 1.5, y: 0 },
+    ],
+  }
+
+  const solver = new InlineNetLabelSolver({
+    inputProblem,
+    traces: [trace],
+    netLabelPlacements: [],
+  })
+  solver.solve()
+
+  expect(solver.inlineNetLabelPlacements).toHaveLength(1)
+  expect(solver.inlineNetLabelPlacements[0]!.side).toBe("y-")
+  expect(solver.inlineNetLabelPlacements[0]!.center.y).toBeLessThan(0)
+})

package/tests/solvers/InlineNetLabelSolver/push-anchored-net-labels-away.test.ts

@@ -11,9 +11,15 @@ test("pushes a regular endpoint label and its wick past nearby inline text", ()
       {
         chipId: "U1",
         center: { x: 0, y: 0 },
-        width: 1,
+        // The routing box includes component text, so the real pins can sit
+        // inside it. A generated connector may legitimately cross that
+        // expanded owner box on its way out from the pin.
+        width: 2,
         height: 1,
-        pins: [],
+        pins: [
+          { pinId: "U1.1", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "U1.2", x: -0.5, y: 0, _facingDirection: "x-" },
+        ],
       },
     ],
     directConnections: [],

package/tests/solvers/InlineNetLabelSolver/push-inline-terminal-labels-away.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test"
+import type { InlineNetLabelPlacement } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+import { pushInlineTerminalLabelsAwayFromAnchoredLabels } from "lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("moves an inline terminal row outward past a retained anchored label", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "J1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [
+          { pinId: "J1.A0", x: -0.5, y: 0.2, _facingDirection: "x-" },
+          { pinId: "J1.SCLK", x: -0.5, y: 0, _facingDirection: "x-" },
+          { pinId: "J1.MISO", x: -0.5, y: -0.2, _facingDirection: "x-" },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const anchoredNetLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "A0",
+      netId: "A0",
+      mspConnectionPairIds: [],
+      pinIds: ["J1.A0"],
+      orientation: "x-",
+      anchorPoint: { x: -0.5, y: 0.2 },
+      center: { x: -0.75, y: 0.2 },
+      width: 0.5,
+      height: 0.2,
+    },
+  ]
+  const inlineNetLabelPlacements: InlineNetLabelPlacement[] = [
+    {
+      globalConnNetId: "SCLK",
+      netId: "SCLK",
+      pinIds: ["J1.SCLK"],
+      stubTracePath: [
+        { x: -0.5, y: 0 },
+        { x: -1.1, y: 0 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -0.8, y: 0 },
+      center: { x: -0.8, y: 0.11 },
+      width: 0.4,
+      height: 0.12,
+      side: "y+",
+    },
+    {
+      globalConnNetId: "MISO",
+      netId: "MISO",
+      pinIds: ["J1.MISO"],
+      stubTracePath: [
+        { x: -0.5, y: -0.2 },
+        { x: -1.1, y: -0.2 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -0.8, y: -0.2 },
+      center: { x: -0.8, y: -0.09 },
+      width: 0.4,
+      height: 0.12,
+      side: "y+",
+    },
+  ]
+
+  const output = pushInlineTerminalLabelsAwayFromAnchoredLabels({
+    inputProblem,
+    traces: [],
+    anchoredNetLabelPlacements,
+    inlineNetLabelPlacements,
+  })
+
+  expect(output.movedGroupCount).toBe(1)
+  expect(output.inlineNetLabelPlacements[0]!.center.x).toBeLessThan(-0.8)
+  expect(output.inlineNetLabelPlacements[1]!.center.x).toBe(
+    output.inlineNetLabelPlacements[0]!.center.x,
+  )
+  expect(output.inlineNetLabelPlacements[0]!.stubTracePath![0]).toEqual({
+    x: -0.5,
+    y: 0,
+  })
+  expect(output.inlineNetLabelPlacements[0]!.stubTracePath![1]!.x).toBeLessThan(
+    -1.1,
+  )
+})

package/tests/solvers/InlineNetLabelSolver/two-pin-terminal-stubs-atomic.test.ts

@@ -36,7 +36,13 @@ test("two-pin terminal stubs fall back atomically when one endpoint is obstructe
         center: { x: -0.85, y: 0.11 },
         width: 1.1,
         height: 0.12,
-        text: "obstacle",
+        text: "upper obstacle",
+      },
+      {
+        center: { x: -0.85, y: -0.11 },
+        width: 1.1,
+        height: 0.12,
+        text: "lower obstacle",
       },
     ],
     availableNetLabelOrientations: { NET_SIGNAL: ["x-", "x+"] },