@tscircuit/schematic-trace-solver 0.0.41 → 0.0.42

package/dist/index.d.ts

@@ -129,6 +129,7 @@ type ChipWithBounds = {
     maxX: number;
     maxY: number;
 };
+declare const getObstacleRects: (problem: InputProblem) => ChipWithBounds[];
 
 declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     pins: MspConnectionPair["pins"];
@@ -381,20 +382,128 @@ declare class NetLabelPlacementSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface TraceLabelOverlapAvoidanceSolverInput {
+interface LabelMergingSolverInput {
+    netLabelPlacements: NetLabelPlacement[];
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
+}
+interface LabelMergingSolverOutput {
     netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
 }
-declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
-    private problem;
+/**
+ * Merges multiple net labels into a single, larger label if they are on the
+ * same side of the same chip, reducing schematic clutter.
+ */
+declare class MergedNetLabelObstacleSolver extends BaseSolver {
+    private input;
+    private output;
+    private inputProblem;
     private traces;
-    private netTempLabelPlacements;
-    private netLabelPlacements;
-    private updatedTraces;
-    private mergedLabelNetIdMap;
+    constructor(solverInput: LabelMergingSolverInput);
+    _step(): void;
+    getOutput(): LabelMergingSolverOutput;
+    visualize(): GraphicsObject;
+}
+
+interface TraceCleanupSolverInput {
+    inputProblem: InputProblem;
+    allTraces: SolvedTracePath[];
+    targetTraceIds: Set<string>;
+    allLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+    paddingBuffer: number;
+}
+/**
+ * Cleans up traces by minimizing turns and balancing L-shapes to improve
+ * the overall aesthetics and readability of the schematic.
+ */
+declare class TraceCleanupSolver extends BaseSolver {
+    private input;
+    private outputTraces;
+    private pipelineStepIndex;
+    private tracesToProcess;
+    private minimizedTraces;
+    private balancedTraces;
+    constructor(solverInput: TraceCleanupSolverInput);
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+    };
+    visualize(): GraphicsObject;
+}
+
+interface SingleOverlapSolverInput {
+    trace: SolvedTracePath;
+    label: NetLabelPlacement;
+    problem: InputProblem;
+    paddingBuffer: number;
+    detourCount: number;
+}
+/**
+ * This solver attempts to find a valid rerouting for a single trace that is
+ * overlapping with a net label. It tries various candidate paths until it
+ * finds one that does not introduce new collisions.
+ */
+declare class SingleOverlapSolver extends BaseSolver {
+    queuedCandidatePaths: Point[][];
+    solvedTracePath: Point[] | null;
+    initialTrace: SolvedTracePath;
+    problem: InputProblem;
+    obstacles: ReturnType<typeof getObstacleRects>;
+    label: NetLabelPlacement;
+    constructor(solverInput: SingleOverlapSolverInput);
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface OverlapCollectionSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+}
+/**
+ * This is an internal solver that manages the step-by-step process of avoiding
+ * multiple overlaps. It follows the pattern of SchematicTraceLinesSolver.
+ */
+declare class OverlapAvoidanceStepSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+    allTraces: SolvedTracePath[];
+    modifiedTraces: SolvedTracePath[];
     private detourCountByLabel;
     private readonly PADDING_BUFFER;
+    activeSubSolver: SingleOverlapSolver | null;
+    private overlapQueue;
+    private recentlyFailed;
+    constructor(solverInput: OverlapCollectionSolverInput);
+    _step(): void;
+    getOutput(): {
+        allTraces: SolvedTracePath[];
+        modifiedTraces: SolvedTracePath[];
+    };
+    visualize(): GraphicsObject;
+}
+
+interface TraceLabelOverlapAvoidanceSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+/**
+ * This solver is a pipeline that runs a series of sub-solvers to resolve
+ * trace-label overlaps and clean up the resulting traces.
+ */
+declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    labelMergingSolver?: MergedNetLabelObstacleSolver;
+    overlapAvoidanceSolver?: OverlapAvoidanceStepSolver;
+    traceCleanupSolver?: TraceCleanupSolver;
+    pipelineStepIndex: number;
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {
@@ -455,7 +564,9 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     longDistancePairSolver?: LongDistancePairSolver;
     traceOverlapShiftSolver?: TraceOverlapShiftSolver;
     netLabelPlacementSolver?: NetLabelPlacementSolver;
+    labelMergingSolver?: MergedNetLabelObstacleSolver;
     traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver;
+    traceCleanupSolver?: TraceCleanupSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;