@tscircuit/schematic-trace-solver 0.0.144 → 0.0.146

package/tests/solvers/InlineNetLabelSolver/inline-net-label-anchored-label-clearance.test.ts

@@ -0,0 +1,28 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import inputProblem from "../../assets/inline-net-label-anchored-label-clearance.json"
+import "tests/fixtures/matcher"
+
+test("regular labels are drawn beyond adjacent inline labels", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem as any)
+
+  solver.solve()
+
+  const output = solver.inlineNetLabelSolver!.getOutput()
+  const regularLabels = output.netLabelPlacements.filter((label) =>
+    ["D_MINUS", "D_PLUS"].includes(label.netId ?? ""),
+  )
+  expect(solver.inlineNetLabelSolver!.stats.pushedAnchoredNetLabelCount).toBe(2)
+  expect(regularLabels).toHaveLength(2)
+  expect(regularLabels[0]!.anchorPoint.x).toBeCloseTo(
+    regularLabels[1]!.anchorPoint.x,
+  )
+  expect(regularLabels[0]!.anchorPoint.x).toBeLessThan(-0.7)
+  expect(
+    output.traces.filter((trace) =>
+      trace.mspPairId.startsWith("inline-net-label-clearance-"),
+    ),
+  ).toHaveLength(2)
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

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

@@ -0,0 +1,227 @@
+import { expect, test } from "bun:test"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { pushAnchoredNetLabelsAwayFromInlineLabels } from "lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels"
+import type { InlineNetLabelPlacement } from "lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver"
+
+test("pushes a regular endpoint label and its wick past nearby inline text", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: 0, y: 0 },
+        width: 1,
+        height: 1,
+        pins: [],
+      },
+    ],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const netLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "regular-net",
+      netId: "D_PLUS",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.1"],
+      orientation: "x-",
+      anchorPoint: { x: -0.7, y: 0.2 },
+      center: { x: -1.2, y: 0.2 },
+      width: 1,
+      height: 0.2,
+    },
+  ]
+  const traces: SolvedTracePath[] = [
+    {
+      mspPairId: "available-net-orientation-0-D_PLUS",
+      dcConnNetId: "regular-net",
+      globalConnNetId: "regular-net",
+      pins: [] as any,
+      tracePath: [
+        { x: -0.5, y: 0.2 },
+        { x: -0.7, y: 0.2 },
+      ],
+      mspConnectionPairIds: [],
+      pinIds: ["U1.1"],
+    },
+  ]
+  const inlineNetLabelPlacements: InlineNetLabelPlacement[] = [
+    {
+      globalConnNetId: "inline-net",
+      netId: "SWCLK",
+      pinIds: ["U1.2"],
+      stubTracePath: [
+        { x: -0.5, y: 0 },
+        { x: -1.7, y: 0 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -1.1, y: 0 },
+      center: { x: -1.1, y: 0.11 },
+      width: 1.2,
+      height: 0.12,
+      side: "y+",
+    },
+  ]
+
+  const output = pushAnchoredNetLabelsAwayFromInlineLabels({
+    inputProblem,
+    traces,
+    netLabelPlacements,
+    inlineNetLabelPlacements,
+  })
+
+  expect(output.movedLabelCount).toBe(1)
+  expect(output.netLabelPlacements[0]!.anchorPoint.x).toBeCloseTo(-1.75)
+  expect(output.netLabelPlacements[0]!.center.x).toBeCloseTo(-2.25)
+  expect(output.traces[0]!.tracePath[0]).toEqual({ x: -0.5, y: 0.2 })
+  expect(output.traces[0]!.tracePath[1]!.x).toBeCloseTo(-1.75)
+  expect(output.traces[0]!.tracePath[1]!.y).toBeCloseTo(0.2)
+})
+
+test("leaves a label without a movable connector in place", () => {
+  const label: NetLabelPlacement = {
+    globalConnNetId: "regular-net",
+    netId: "D_PLUS",
+    mspConnectionPairIds: ["routed-pair"],
+    pinIds: ["U1.1", "J1.1"],
+    orientation: "x-",
+    anchorPoint: { x: -0.7, y: 0.2 },
+    center: { x: -1.2, y: 0.2 },
+    width: 1,
+    height: 0.2,
+  }
+  const inlineLabel: InlineNetLabelPlacement = {
+    globalConnNetId: "inline-net",
+    netId: "SWCLK",
+    pinIds: ["U1.2"],
+    axis: "x",
+    anchorPoint: { x: -1.1, y: 0 },
+    center: { x: -1.1, y: 0.11 },
+    width: 1.2,
+    height: 0.12,
+    side: "y+",
+  }
+
+  const output = pushAnchoredNetLabelsAwayFromInlineLabels({
+    inputProblem: {
+      chips: [],
+      directConnections: [],
+      netConnections: [],
+      availableNetLabelOrientations: {},
+    },
+    traces: [],
+    netLabelPlacements: [label],
+    inlineNetLabelPlacements: [inlineLabel],
+  })
+
+  expect(output.movedLabelCount).toBe(0)
+  expect(output.netLabelPlacements[0]).toEqual(label)
+})
+
+test("moves a contiguous label row together and shoves an anchored obstacle", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U1",
+        center: { x: 0, y: 0.2 },
+        width: 1.4,
+        height: 1,
+        pins: [
+          { pinId: "U1.minus", x: -0.7, y: 0.4, _facingDirection: "x-" },
+          { pinId: "U1.plus", x: -0.7, y: 0.2, _facingDirection: "x-" },
+          { pinId: "U1.inline", x: -0.7, y: 0, _facingDirection: "x-" },
+          { pinId: "U1.gnd1", x: -0.7, y: 0.5, _facingDirection: "x-" },
+          { pinId: "U1.gnd2", x: -2.5, y: 0.5, _facingDirection: "x+" },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [],
+    availableNetLabelOrientations: {},
+  }
+  const netLabelPlacements: NetLabelPlacement[] = [
+    {
+      globalConnNetId: "minus-net",
+      netId: "D_MINUS",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.minus"],
+      orientation: "x-",
+      anchorPoint: { x: -0.7, y: 0.4 },
+      center: { x: -1.2, y: 0.4 },
+      width: 1,
+      height: 0.2,
+    },
+    {
+      globalConnNetId: "plus-net",
+      netId: "D_PLUS",
+      mspConnectionPairIds: [],
+      pinIds: ["U1.plus"],
+      orientation: "x-",
+      anchorPoint: { x: -0.7, y: 0.2 },
+      center: { x: -1.2, y: 0.2 },
+      width: 1,
+      height: 0.2,
+    },
+    {
+      globalConnNetId: "gnd-net",
+      netId: "GND",
+      mspConnectionPairIds: ["gnd-route"],
+      pinIds: ["U1.gnd1", "U1.gnd2"],
+      orientation: "y-",
+      anchorPoint: { x: -2.5, y: 0.5 },
+      center: { x: -2.5, y: 0.3 },
+      width: 0.4,
+      height: 0.4,
+    },
+  ]
+  const traces: SolvedTracePath[] = [
+    {
+      mspPairId: "gnd-route",
+      dcConnNetId: "gnd-net",
+      globalConnNetId: "gnd-net",
+      pins: [] as any,
+      tracePath: [
+        { x: -0.7, y: 0.5 },
+        { x: -2.5, y: 0.5 },
+      ],
+      mspConnectionPairIds: ["gnd-route"],
+      pinIds: ["U1.gnd1", "U1.gnd2"],
+    },
+  ]
+  const inlineNetLabelPlacements: InlineNetLabelPlacement[] = [
+    {
+      globalConnNetId: "inline-net",
+      netId: "SWCLK",
+      pinIds: ["U1.inline"],
+      stubTracePath: [
+        { x: -0.7, y: 0 },
+        { x: -1.9, y: 0 },
+      ],
+      axis: "x",
+      anchorPoint: { x: -1.3, y: 0 },
+      center: { x: -1.1, y: 0.11 },
+      width: 1.2,
+      height: 0.12,
+      side: "y+",
+    },
+  ]
+
+  const output = pushAnchoredNetLabelsAwayFromInlineLabels({
+    inputProblem,
+    traces,
+    netLabelPlacements,
+    inlineNetLabelPlacements,
+  })
+
+  expect(output.movedLabelCount).toBe(3)
+  expect(output.netLabelPlacements[0]!.anchorPoint.x).toBeCloseTo(-1.75)
+  expect(output.netLabelPlacements[1]!.anchorPoint.x).toBeCloseTo(-1.75)
+  expect(output.netLabelPlacements[2]!.center.x).toBeLessThan(-2.5)
+  expect(
+    output.traces.filter((trace) =>
+      trace.mspPairId.startsWith("inline-net-label-clearance-"),
+    ),
+  ).toHaveLength(3)
+})

package/tests/solvers/MspConnectionPairSolver/msp-connection-pair-solver-direct-connection-distance.test.ts

@@ -44,3 +44,83 @@ test("two-pin direct connections use Euclidean max distance", () => {
   expect(directConnectionSolver.mspConnectionPairs).toHaveLength(1)
   expect(netConnectionSolver.mspConnectionPairs).toHaveLength(0)
 })
+
+test("routes a distant labeled connection when opposed fallback labels would overlap", () => {
+  const inputProblem = createInputProblem()
+  inputProblem.maxMspPairDistance = 1
+  inputProblem.chips[0]!.sectionId = "power-output"
+  inputProblem.chips[1]!.sectionId = "power-output"
+  inputProblem.chips[0]!.pins.push({
+    pinId: "U1.2",
+    x: 0,
+    y: -0.2,
+    _facingDirection: "x+",
+  })
+  inputProblem.chips[1]!.pins.push({
+    pinId: "U2.2",
+    x: 2,
+    y: 1.8,
+    _facingDirection: "x-",
+  })
+  inputProblem.chips[1]!.pins[0]!.y = 0.1
+  inputProblem.directConnections[0]!.netId = "LONG_POWER_NAME"
+  inputProblem.directConnections[0]!.netLabelWidth = 1.2
+
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+
+  expect(solver.mspConnectionPairs).toHaveLength(1)
+  expect(solver.mspConnectionPairs[0]?.suppressNetLabel).toBe(true)
+})
+
+test("keeps distant labeled fallback when opposed labels have room", () => {
+  const inputProblem = createInputProblem()
+  inputProblem.maxMspPairDistance = 1
+  inputProblem.chips[0]!.sectionId = "power-output"
+  inputProblem.chips[1]!.sectionId = "power-output"
+  inputProblem.chips[0]!.pins.push({
+    pinId: "U1.2",
+    x: 0,
+    y: -0.2,
+    _facingDirection: "x+",
+  })
+  inputProblem.chips[1]!.pins.push({
+    pinId: "U2.2",
+    x: 2,
+    y: 1.8,
+    _facingDirection: "x-",
+  })
+  inputProblem.chips[1]!.pins[0]!.y = 0.1
+  inputProblem.directConnections[0]!.netId = "SIG"
+  inputProblem.directConnections[0]!.netLabelWidth = 0.6
+
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+
+  expect(solver.mspConnectionPairs).toHaveLength(0)
+})
+
+test("does not apply the overlap fallback outside a shared schematic section", () => {
+  const inputProblem = createInputProblem()
+  inputProblem.maxMspPairDistance = 1
+  inputProblem.chips[0]!.pins.push({
+    pinId: "U1.2",
+    x: 0,
+    y: -0.2,
+    _facingDirection: "x+",
+  })
+  inputProblem.chips[1]!.pins.push({
+    pinId: "U2.2",
+    x: 2,
+    y: 1.8,
+    _facingDirection: "x-",
+  })
+  inputProblem.chips[1]!.pins[0]!.y = 0.1
+  inputProblem.directConnections[0]!.netId = "LONG_POWER_NAME"
+  inputProblem.directConnections[0]!.netLabelWidth = 1.2
+
+  const solver = new MspConnectionPairSolver({ inputProblem })
+  solver.solve()
+
+  expect(solver.mspConnectionPairs).toHaveLength(0)
+})