@tscircuit/schematic-trace-solver 0.0.38 → 0.0.39

package/dist/index.d.ts

@@ -392,14 +392,13 @@ declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     private netTempLabelPlacements;
     private netLabelPlacements;
     private updatedTraces;
-    private updatedTracesMap;
     private mergedLabelNetIdMap;
     private detourCountByLabel;
     private readonly PADDING_BUFFER;
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {
-        traceMap: Map<string, SolvedTracePath>;
+        traces: SolvedTracePath[];
         netLabelPlacements: NetLabelPlacement[];
     };
     visualize(): GraphicsObject;

package/dist/index.js

@@ -1015,12 +1015,12 @@ var applyJogToTerminalSegment = ({
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical3 = Math.abs(start.x - end.x) < EPS4;
-  const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-  if (!isVertical3 && !isHorizontal3) return;
-  const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+  if (!isVertical2 && !isHorizontal2) return;
+  const segDir = isVertical2 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical3) {
+    if (isVertical2) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1040,7 +1040,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical3) {
+    if (isVertical2) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1120,10 +1120,10 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical3 = Math.abs(start.x - end.x) < EPS4;
-            const isHorizontal3 = Math.abs(start.y - end.y) < EPS4;
-            if (!isVertical3 && !isHorizontal3) continue;
-            if (isVertical3) {
+            const isVertical2 = Math.abs(start.x - end.x) < EPS4;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS4;
+            if (!isVertical2 && !isHorizontal2) continue;
+            if (isVertical2) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -2508,6 +2508,32 @@ var countTurns = (points) => {
   return turns;
 };
 
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/tryConnectPoints.ts
+var tryConnectPoints = (start, end) => {
+  const candidates = [];
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end]);
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end]);
+    candidates.push([start, { x: start.x, y: end.y }, end]);
+  }
+  return candidates;
+};
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisionsWithLabels.ts
+var hasCollisionsWithLabels = (pathSegments, labels) => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i];
+    const p2 = pathSegments[i + 1];
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts
 var minimizeTurns = ({
   path,
@@ -2517,28 +2543,6 @@ var minimizeTurns = ({
   if (path.length <= 2) {
     return path;
   }
-  const hasCollisionsWithLabels = (pathSegments, labels) => {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-      const p1 = pathSegments[i];
-      const p2 = pathSegments[i + 1];
-      for (const label of labels) {
-        if (segmentIntersectsRect(p1, p2, label)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-  const tryConnectPoints = (start, end) => {
-    const candidates = [];
-    if (start.x === end.x || start.y === end.y) {
-      candidates.push([start, end]);
-    } else {
-      candidates.push([start, { x: end.x, y: start.y }, end]);
-      candidates.push([start, { x: start.x, y: end.y }, end]);
-    }
-    return candidates;
-  };
   const recognizeStairStepPattern = (pathToCheck, startIdx) => {
     if (startIdx >= pathToCheck.length - 3) return -1;
     let endIdx = startIdx;
@@ -2672,6 +2676,8 @@ var minimizeTurns = ({
   const finalSimplifiedPath = simplifyPath(optimizedPath);
   return finalSimplifiedPath;
 };
+
+// lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   traces,
   problem,
@@ -2684,7 +2690,7 @@ var minimizeTurnsWithFilteredLabels = ({
   const newTraces = traces.map((trace) => {
     const originalPath = trace.tracePath;
     const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap.get(label.globalConnNetId);
+      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
       if (originalNetIds) {
         return !originalNetIds.has(trace.globalConnNetId);
       }
@@ -2865,7 +2871,6 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   netTempLabelPlacements;
   netLabelPlacements;
   updatedTraces;
-  updatedTracesMap;
   mergedLabelNetIdMap;
   detourCountByLabel;
   PADDING_BUFFER = 0.1;
@@ -2874,28 +2879,27 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     this.problem = solverInput.inputProblem;
     this.traces = solverInput.traces;
     this.updatedTraces = [...solverInput.traces];
-    this.updatedTracesMap = /* @__PURE__ */ new Map();
-    this.mergedLabelNetIdMap = /* @__PURE__ */ new Map();
-    this.detourCountByLabel = /* @__PURE__ */ new Map();
+    this.mergedLabelNetIdMap = {};
+    this.detourCountByLabel = {};
     const originalLabels = solverInput.netLabelPlacements;
     this.netLabelPlacements = originalLabels;
     if (!originalLabels || originalLabels.length === 0) {
       this.netTempLabelPlacements = [];
       return;
     }
-    const labelGroups = /* @__PURE__ */ new Map();
+    const labelGroups = {};
     for (const p of originalLabels) {
       if (p.pinIds.length === 0) continue;
       const chipId = p.pinIds[0].split(".")[0];
       if (!chipId) continue;
       const key = `${chipId}-${p.orientation}`;
-      if (!labelGroups.has(key)) {
-        labelGroups.set(key, []);
+      if (!(key in labelGroups)) {
+        labelGroups[key] = [];
       }
-      labelGroups.get(key).push(p);
+      labelGroups[key].push(p);
     }
     const finalPlacements = [];
-    for (const [key, group] of labelGroups.entries()) {
+    for (const [key, group] of Object.entries(labelGroups)) {
       if (group.length <= 1) {
         finalPlacements.push(...group);
         continue;
@@ -2913,7 +2917,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       const template = group[0];
       const syntheticId = `merged-group-${key}`;
       const originalNetIds = new Set(group.map((p) => p.globalConnNetId));
-      this.mergedLabelNetIdMap.set(syntheticId, originalNetIds);
+      this.mergedLabelNetIdMap[syntheticId] = originalNetIds;
       finalPlacements.push({
         ...template,
         globalConnNetId: syntheticId,
@@ -2933,7 +2937,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    this.detourCountByLabel.clear();
+    this.detourCountByLabel = {};
     const overlaps = detectTraceLabelOverlap(
       this.traces,
       this.netTempLabelPlacements
@@ -2943,9 +2947,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       return;
     }
     const unfriendlyOverlaps = overlaps.filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap.get(
-        o.label.globalConnNetId
-      );
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId];
       if (originalNetIds) {
         return !originalNetIds.has(o.trace.globalConnNetId);
       }
@@ -2955,18 +2957,18 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    const updatedTracesMap = /* @__PURE__ */ new Map();
+    const updatedTracesMap = {};
     for (const trace of this.traces) {
-      updatedTracesMap.set(trace.mspPairId, trace);
+      updatedTracesMap[trace.mspPairId] = trace;
     }
     const processedTraceIds = /* @__PURE__ */ new Set();
     for (const overlap of unfriendlyOverlaps) {
       if (processedTraceIds.has(overlap.trace.mspPairId)) {
         continue;
       }
-      const currentTraceState = updatedTracesMap.get(overlap.trace.mspPairId);
+      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId];
       const labelId = overlap.label.globalConnNetId;
-      const detourCount = this.detourCountByLabel.get(labelId) || 0;
+      const detourCount = this.detourCountByLabel[labelId] || 0;
       const newTrace = rerouteCollidingTrace({
         trace: currentTraceState,
         label: overlap.label,
@@ -2975,12 +2977,12 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
         detourCount
       });
       if (newTrace.tracePath !== currentTraceState.tracePath) {
-        this.detourCountByLabel.set(labelId, detourCount + 1);
+        this.detourCountByLabel[labelId] = detourCount + 1;
       }
-      updatedTracesMap.set(currentTraceState.mspPairId, newTrace);
+      updatedTracesMap[currentTraceState.mspPairId] = newTrace;
       processedTraceIds.add(currentTraceState.mspPairId);
     }
-    this.updatedTraces = Array.from(updatedTracesMap.values());
+    this.updatedTraces = Object.values(updatedTracesMap);
     const minimizedTraces = minimizeTurnsWithFilteredLabels({
       traces: this.updatedTraces,
       problem: this.problem,
@@ -3000,13 +3002,11 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     if (balancedTraces) {
       this.updatedTraces = balancedTraces;
     }
-    this.updatedTracesMap.clear();
-    for (const trace of this.updatedTraces) {
-      this.updatedTracesMap.set(trace.mspPairId, trace);
-    }
     const finalLabelPlacementSolver = new NetLabelPlacementSolver({
       inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(this.updatedTracesMap)
+      inputTraceMap: Object.fromEntries(
+        this.updatedTraces.map((trace) => [trace.mspPairId, trace])
+      )
     });
     finalLabelPlacementSolver.solve();
     this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements;
@@ -3014,7 +3014,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
   }
   getOutput() {
     return {
-      traceMap: this.updatedTracesMap,
+      traces: this.updatedTraces,
       netLabelPlacements: this.netLabelPlacements
     };
   }
@@ -3024,7 +3024,7 @@ var TraceLabelOverlapAvoidanceSolver = class extends BaseSolver {
     if (!graphics.circles) graphics.circles = [];
     if (!graphics.texts) graphics.texts = [];
     if (!graphics.rects) graphics.rects = [];
-    for (const trace of Object.values(this.updatedTraces)) {
+    for (const trace of this.updatedTraces) {
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "purple"

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver.ts

@@ -8,7 +8,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { getRectBounds } from "../NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import type { InputProblem } from "lib/types/InputProblem"
-import { minimizeTurnsWithFilteredLabels } from "./turnMinimization"
+import { minimizeTurnsWithFilteredLabels } from "./minimizeTurnsWithFilteredLabels"
 import { balanceLShapes } from "./balanceLShapes"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 
@@ -24,9 +24,8 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
   private netTempLabelPlacements: NetLabelPlacement[]
   private netLabelPlacements: NetLabelPlacement[]
   private updatedTraces: SolvedTracePath[]
-  private updatedTracesMap: Map<string, SolvedTracePath>
-  private mergedLabelNetIdMap: Map<string, Set<string>>
-  private detourCountByLabel: Map<string, number>
+  private mergedLabelNetIdMap: Record<string, Set<string>>
+  private detourCountByLabel: Record<string, number>
   private readonly PADDING_BUFFER = 0.1
 
   constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput) {
@@ -34,9 +33,8 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     this.problem = solverInput.inputProblem
     this.traces = solverInput.traces
     this.updatedTraces = [...solverInput.traces]
-    this.updatedTracesMap = new Map()
-    this.mergedLabelNetIdMap = new Map()
-    this.detourCountByLabel = new Map()
+    this.mergedLabelNetIdMap = {}
+    this.detourCountByLabel = {}
 
     const originalLabels = solverInput.netLabelPlacements
     this.netLabelPlacements = originalLabels
@@ -45,21 +43,21 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    const labelGroups = new Map<string, NetLabelPlacement[]>()
+    const labelGroups: Record<string, NetLabelPlacement[]> = {}
 
     for (const p of originalLabels) {
       if (p.pinIds.length === 0) continue
       const chipId = p.pinIds[0].split(".")[0]
       if (!chipId) continue
       const key = `${chipId}-${p.orientation}`
-      if (!labelGroups.has(key)) {
-        labelGroups.set(key, [])
+      if (!(key in labelGroups)) {
+        labelGroups[key] = []
       }
-      labelGroups.get(key)!.push(p)
+      labelGroups[key]!.push(p)
     }
 
     const finalPlacements: NetLabelPlacement[] = []
-    for (const [key, group] of labelGroups.entries()) {
+    for (const [key, group] of Object.entries(labelGroups)) {
       if (group.length <= 1) {
         finalPlacements.push(...group)
         continue
@@ -82,7 +80,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       const template = group[0]!
       const syntheticId = `merged-group-${key}`
       const originalNetIds = new Set(group.map((p) => p.globalConnNetId))
-      this.mergedLabelNetIdMap.set(syntheticId, originalNetIds)
+      this.mergedLabelNetIdMap[syntheticId] = originalNetIds
 
       finalPlacements.push({
         ...template,
@@ -111,7 +109,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    this.detourCountByLabel.clear()
+    this.detourCountByLabel = {}
 
     const overlaps = detectTraceLabelOverlap(
       this.traces,
@@ -124,9 +122,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     }
 
     const unfriendlyOverlaps = overlaps.filter((o) => {
-      const originalNetIds = this.mergedLabelNetIdMap.get(
-        o.label.globalConnNetId,
-      )
+      const originalNetIds = this.mergedLabelNetIdMap[o.label.globalConnNetId]
       if (originalNetIds) {
         return !originalNetIds.has(o.trace.globalConnNetId)
       }
@@ -138,9 +134,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       return
     }
 
-    const updatedTracesMap = new Map<string, SolvedTracePath>()
+    const updatedTracesMap: Record<string, SolvedTracePath> = {}
     for (const trace of this.traces) {
-      updatedTracesMap.set(trace.mspPairId, trace)
+      updatedTracesMap[trace.mspPairId] = trace
     }
 
     const processedTraceIds = new Set<string>()
@@ -150,9 +146,9 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
         continue
       }
 
-      const currentTraceState = updatedTracesMap.get(overlap.trace.mspPairId)!
+      const currentTraceState = updatedTracesMap[overlap.trace.mspPairId]!
       const labelId = overlap.label.globalConnNetId
-      const detourCount = this.detourCountByLabel.get(labelId) || 0
+      const detourCount = this.detourCountByLabel[labelId] || 0
 
       const newTrace = rerouteCollidingTrace({
         trace: currentTraceState,
@@ -163,14 +159,14 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       })
 
       if (newTrace.tracePath !== currentTraceState.tracePath) {
-        this.detourCountByLabel.set(labelId, detourCount + 1)
+        this.detourCountByLabel[labelId] = detourCount + 1
       }
 
-      updatedTracesMap.set(currentTraceState.mspPairId, newTrace)
+      updatedTracesMap[currentTraceState.mspPairId] = newTrace
       processedTraceIds.add(currentTraceState.mspPairId)
     }
 
-    this.updatedTraces = Array.from(updatedTracesMap.values())
+    this.updatedTraces = Object.values(updatedTracesMap)
 
     const minimizedTraces = minimizeTurnsWithFilteredLabels({
       traces: this.updatedTraces,
@@ -191,14 +187,11 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
       this.updatedTraces = balancedTraces
     }
 
-    this.updatedTracesMap.clear()
-    for (const trace of this.updatedTraces) {
-      this.updatedTracesMap.set(trace.mspPairId, trace)
-    }
-
     const finalLabelPlacementSolver = new NetLabelPlacementSolver({
       inputProblem: this.problem,
-      inputTraceMap: Object.fromEntries(this.updatedTracesMap),
+      inputTraceMap: Object.fromEntries(
+        this.updatedTraces.map((trace) => [trace.mspPairId, trace]),
+      ),
     })
     finalLabelPlacementSolver.solve()
     this.netLabelPlacements = finalLabelPlacementSolver.netLabelPlacements
@@ -208,7 +201,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
 
   getOutput() {
     return {
-      traceMap: this.updatedTracesMap,
+      traces: this.updatedTraces,
       netLabelPlacements: this.netLabelPlacements,
     }
   }
@@ -221,7 +214,7 @@ export class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     if (!graphics.texts) graphics.texts = []
     if (!graphics.rects) graphics.rects = []
 
-    for (const trace of Object.values(this.updatedTraces)) {
+    for (const trace of this.updatedTraces) {
       graphics.lines!.push({
         points: trace.tracePath,
         strokeColor: "purple",

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisions.ts

@@ -1,9 +1,5 @@
 import type { Point } from "graphics-debug"
-import {
-  isVertical,
-  isHorizontal,
-  segmentIntersectsRect,
-} from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 
 export const hasCollisions = (
   pathSegments: Point[],

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/hasCollisionsWithLabels.ts

@@ -0,0 +1,19 @@
+import type { Point } from "@tscircuit/math-utils"
+import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+
+export const hasCollisionsWithLabels = (
+  pathSegments: Point[],
+  labels: any[],
+): boolean => {
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const p1 = pathSegments[i]
+    const p2 = pathSegments[i + 1]
+
+    for (const label of labels) {
+      if (segmentIntersectsRect(p1, p2, label)) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/minimizeTurnsWithFilteredLabels.ts

@@ -0,0 +1,66 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { minimizeTurns } from "./turnMinimization"
+
+export const minimizeTurnsWithFilteredLabels = ({
+  traces,
+  problem,
+  allLabelPlacements,
+  mergedLabelNetIdMap,
+  paddingBuffer,
+}: {
+  traces: SolvedTracePath[]
+  problem: InputProblem
+  allLabelPlacements: NetLabelPlacement[]
+  mergedLabelNetIdMap: Record<string, Set<string>>
+  paddingBuffer: number
+}): SolvedTracePath[] | null => {
+  let changesMade = false
+  const obstacles = getObstacleRects(problem)
+
+  const newTraces = traces.map((trace) => {
+    const originalPath = trace.tracePath
+    const filteredLabels = allLabelPlacements.filter((label) => {
+      const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
+      if (originalNetIds) {
+        return !originalNetIds.has(trace.globalConnNetId)
+      }
+      return label.globalConnNetId !== trace.globalConnNetId
+    })
+
+    const labelBounds = filteredLabels.map((nl) => ({
+      minX: nl.center.x - nl.width / 2 - paddingBuffer,
+      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
+      minY: nl.center.y - nl.height / 2 - paddingBuffer,
+      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
+    }))
+
+    const newPath = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds,
+    })
+
+    if (
+      newPath.length !== originalPath.length ||
+      newPath.some(
+        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
+      )
+    ) {
+      changesMade = true
+    }
+
+    return {
+      ...trace,
+      tracePath: newPath,
+    }
+  })
+
+  if (changesMade) {
+    return newTraces
+  } else {
+    return null
+  }
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/tryConnectPoints.ts

@@ -0,0 +1,14 @@
+import type { Point } from "@tscircuit/math-utils"
+
+export const tryConnectPoints = (start: Point, end: Point): Point[][] => {
+  const candidates: Point[][] = []
+
+  if (start.x === end.x || start.y === end.y) {
+    candidates.push([start, end])
+  } else {
+    candidates.push([start, { x: end.x, y: start.y }, end])
+    candidates.push([start, { x: start.x, y: end.y }, end])
+  }
+
+  return candidates
+}

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/turnMinimization.ts

@@ -1,14 +1,11 @@
 import type { Point } from "graphics-debug"
-import type { InputProblem } from "lib/types/InputProblem"
-import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
-import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { segmentIntersectsRect } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { hasCollisions } from "./hasCollisions"
 import { countTurns } from "./countTurns"
 import { simplifyPath } from "./simplifyPath"
+import { tryConnectPoints } from "./tryConnectPoints"
+import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
 
-const minimizeTurns = ({
+export const minimizeTurns = ({
   path,
   obstacles,
   labelBounds,
@@ -21,36 +18,6 @@ const minimizeTurns = ({
     return path
   }
 
-  const hasCollisionsWithLabels = (
-    pathSegments: Point[],
-    labels: any[],
-  ): boolean => {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-      const p1 = pathSegments[i]
-      const p2 = pathSegments[i + 1]
-
-      for (const label of labels) {
-        if (segmentIntersectsRect(p1, p2, label)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
-
-  const tryConnectPoints = (start: Point, end: Point): Point[][] => {
-    const candidates: Point[][] = []
-
-    if (start.x === end.x || start.y === end.y) {
-      candidates.push([start, end])
-    } else {
-      candidates.push([start, { x: end.x, y: start.y }, end])
-      candidates.push([start, { x: start.x, y: end.y }, end])
-    }
-
-    return candidates
-  }
-
   const recognizeStairStepPattern = (
     pathToCheck: Point[],
     startIdx: number,
@@ -242,64 +209,3 @@ const minimizeTurns = ({
   const finalSimplifiedPath = simplifyPath(optimizedPath)
   return finalSimplifiedPath
 }
-
-export const minimizeTurnsWithFilteredLabels = ({
-  traces,
-  problem,
-  allLabelPlacements,
-  mergedLabelNetIdMap,
-  paddingBuffer,
-}: {
-  traces: SolvedTracePath[]
-  problem: InputProblem
-  allLabelPlacements: NetLabelPlacement[]
-  mergedLabelNetIdMap: Map<string, Set<string>>
-  paddingBuffer: number
-}): SolvedTracePath[] | null => {
-  let changesMade = false
-  const obstacles = getObstacleRects(problem)
-
-  const newTraces = traces.map((trace) => {
-    const originalPath = trace.tracePath
-    const filteredLabels = allLabelPlacements.filter((label) => {
-      const originalNetIds = mergedLabelNetIdMap.get(label.globalConnNetId)
-      if (originalNetIds) {
-        return !originalNetIds.has(trace.globalConnNetId)
-      }
-      return label.globalConnNetId !== trace.globalConnNetId
-    })
-
-    const labelBounds = filteredLabels.map((nl) => ({
-      minX: nl.center.x - nl.width / 2 - paddingBuffer,
-      maxX: nl.center.x + nl.width / 2 + paddingBuffer,
-      minY: nl.center.y - nl.height / 2 - paddingBuffer,
-      maxY: nl.center.y + nl.height / 2 + paddingBuffer,
-    }))
-
-    const newPath = minimizeTurns({
-      path: originalPath,
-      obstacles,
-      labelBounds,
-    })
-
-    if (
-      newPath.length !== originalPath.length ||
-      newPath.some(
-        (p, i) => p.x !== originalPath[i].x || p.y !== originalPath[i].y,
-      )
-    ) {
-      changesMade = true
-    }
-
-    return {
-      ...trace,
-      tracePath: newPath,
-    }
-  })
-
-  if (changesMade) {
-    return newTraces
-  } else {
-    return null
-  }
-}

package/package.json

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