@tscircuit/schematic-trace-solver 0.0.96 → 0.0.98

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-obstacle.test.ts

@@ -0,0 +1,28 @@
+import { expect, test } from "bun:test"
+import {
+  align,
+  getVerticalRailTraces,
+  verticalProblem,
+} from "./fixtures/alignSameNetRails"
+
+test("does not align through an obstacle", () => {
+  const traces = getVerticalRailTraces()
+  const result = align(traces, {
+    inputProblem: {
+      ...verticalProblem,
+      chips: [
+        ...verticalProblem.chips,
+        {
+          chipId: "barrier",
+          center: { x: -2.5, y: 0 },
+          width: 0.4,
+          height: 0.4,
+          pins: [],
+        },
+      ],
+    },
+  })
+
+  expect(result.alignedRailGroupCount).toBe(0)
+  expect(result.traces).toEqual(traces)
+})

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-pipeline-label-connector.test.ts

@@ -0,0 +1,52 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+test("pipeline does not stretch a real loop toward a generated label connector", () => {
+  const inputProblem: InputProblem = {
+    chips: [
+      {
+        chipId: "U3",
+        center: { x: 0, y: 0 },
+        width: 2.8,
+        height: 1.4,
+        pins: [
+          { pinId: "U3.3", x: 1.4, y: -0.3 },
+          { pinId: "U3.7", x: 1.4, y: -0.5 },
+        ],
+      },
+    ],
+    directConnections: [],
+    netConnections: [
+      {
+        netId: "V3_3",
+        pinIds: ["U3.3", "U3.7"],
+        netLabelWidth: 0.42,
+        netLabelHeight: 0.6,
+      },
+    ],
+    textBoxes: [],
+    availableNetLabelOrientations: { V3_3: ["y+"] },
+    maxMspPairDistance: 2.4,
+  }
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  const traces = solver.traceCleanupSolver2!.getOutput().traces
+  const realTrace = traces.find((trace) => trace.mspPairId === "U3.3-U3.7")!
+  const labelConnector = traces.find((trace) =>
+    trace.mspPairId.startsWith("available-net-orientation-"),
+  )!
+  expect(realTrace.tracePath).toEqual([
+    { x: 1.4, y: -0.3 },
+    { x: 1.5999999999999999, y: -0.3 },
+    { x: 1.5999999999999999, y: -0.5 },
+    { x: 1.4, y: -0.5 },
+  ])
+  expect(labelConnector.mspPairId).toBe("available-net-orientation-0-V3_3")
+  expect(solver.traceCleanupSolver2!.stats).toMatchObject({
+    alignedRailGroupCount: 0,
+    alignedTraceCount: 0,
+  })
+})

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-vertical.test.ts

@@ -0,0 +1,25 @@
+import { expect, test } from "bun:test"
+import { align, getVerticalRailTraces } from "./fixtures/alignSameNetRails"
+
+test("aligns same-net rails on one component side", () => {
+  const result = align(getVerticalRailTraces())
+
+  expect(result).toMatchObject({
+    alignedRailGroupCount: 1,
+    alignedTraceCount: 1,
+  })
+  expect(result.traces.map((trace) => trace.tracePath)).toEqual([
+    [
+      { x: -1, y: 2 },
+      { x: -2, y: 2 },
+      { x: -2, y: 0 },
+      { x: -1, y: 0 },
+    ],
+    [
+      { x: -1, y: 0 },
+      { x: -2, y: 0 },
+      { x: -2, y: -2 },
+      { x: -1, y: -2 },
+    ],
+  ])
+})

package/tests/solvers/TraceCleanupSolver/alignSameNetRails-visible-length.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test"
+import {
+  align,
+  createTrace,
+  getVerticalPin,
+  getVerticalRailTraces,
+  verticalProblem,
+} from "./fixtures/alignSameNetRails"
+
+test("keeps the baseline when alignment would only lengthen visible geometry", () => {
+  const traces = getVerticalRailTraces()
+  traces[1] = createTrace(
+    "lower",
+    [
+      { x: -1, y: 0 },
+      { x: -10, y: 0 },
+      { x: -10, y: -2 },
+      { x: -1, y: -2 },
+    ],
+    [getVerticalPin("U1.2"), getVerticalPin("U1.3")],
+  )
+  const result = align(traces, {
+    inputProblem: {
+      ...verticalProblem,
+      chips: [
+        ...verticalProblem.chips,
+        {
+          chipId: "blocks-short-candidate",
+          center: { x: -2, y: -1 },
+          width: 0.2,
+          height: 0.4,
+          pins: [],
+        },
+      ],
+    },
+  })
+
+  expect(result.alignedRailGroupCount).toBe(0)
+  expect(result.traces).toEqual(traces)
+})

package/tests/solvers/TraceCleanupSolver/fixtures/alignSameNetRails.ts

@@ -0,0 +1,89 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { alignSameNetRails } from "lib/solvers/TraceCleanupSolver/alignSameNetRails"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+
+export const verticalProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "U1",
+      center: { x: 0, y: 0 },
+      width: 2,
+      height: 6,
+      pins: [
+        { pinId: "U1.1", x: -1, y: 2, _facingDirection: "x-" },
+        { pinId: "U1.2", x: -1, y: 0, _facingDirection: "x-" },
+        { pinId: "U1.3", x: -1, y: -2, _facingDirection: "x-" },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [],
+  textBoxes: [],
+  availableNetLabelOrientations: {},
+}
+
+export const getVerticalPin = (
+  pinId: string,
+): InputPin & { chipId: string } => {
+  const inputPin = verticalProblem.chips[0]!.pins.find(
+    (candidate) => candidate.pinId === pinId,
+  )!
+  return { ...inputPin, chipId: "U1" }
+}
+
+export const createTrace = (
+  mspPairId: string,
+  tracePath: Array<{ x: number; y: number }>,
+  pins: SolvedTracePath["pins"],
+  globalConnNetId = "power-net",
+): SolvedTracePath => ({
+  mspPairId,
+  globalConnNetId,
+  dcConnNetId: mspPairId,
+  userNetId: "POWER",
+  pins,
+  tracePath,
+  mspConnectionPairIds: [mspPairId],
+  pinIds: pins.map((item) => item.pinId),
+})
+
+export const getVerticalRailTraces = () => [
+  createTrace(
+    "upper",
+    [
+      { x: -1, y: 2 },
+      { x: -2, y: 2 },
+      { x: -2, y: 0 },
+      { x: -1, y: 0 },
+    ],
+    [getVerticalPin("U1.1"), getVerticalPin("U1.2")],
+  ),
+  createTrace(
+    "lower",
+    [
+      { x: -1, y: 0 },
+      { x: -3, y: 0 },
+      { x: -3, y: -2 },
+      { x: -1, y: -2 },
+    ],
+    [getVerticalPin("U1.2"), getVerticalPin("U1.3")],
+  ),
+]
+
+export const align = (
+  traces: SolvedTracePath[],
+  options: {
+    inputProblem?: InputProblem
+    netLabelPlacements?: NetLabelPlacement[]
+    eligibleTraceIds?: ReadonlySet<string>
+  } = {},
+) =>
+  alignSameNetRails({
+    inputProblem: options.inputProblem ?? verticalProblem,
+    traces,
+    netLabelPlacements: options.netLabelPlacements ?? [],
+    eligibleTraceIds:
+      options.eligibleTraceIds ??
+      new Set(traces.map((trace) => trace.mspPairId)),
+  })