@tscircuit/schematic-trace-solver 0.0.75 → 0.0.77

package/dist/index.js

@@ -357,6 +357,16 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
       });
     }
   }
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    graphics.rects.push({
+      label: textBox.text ?? "schematic_text",
+      center: textBox.center,
+      width: textBox.width,
+      height: textBox.height,
+      fill: "rgba(160, 0, 220, 0.14)",
+      strokeColor: "rgba(160, 0, 220, 0.9)"
+    });
+  }
   for (const directConn of inputProblem.directConnections) {
     const [pinId1, pinId2] = directConn.pinIds;
     const pin1 = pinIdMap.get(pinId1);
@@ -6902,6 +6912,58 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/dedupeOrientations.ts
+var dedupeOrientations = (orientations) => [
+  ...new Set(orientations)
+];
+
+// lib/utils/dedupeStrings.ts
+var dedupeStrings = (values) => [
+  ...new Set(values.filter((value) => value !== void 0))
+];
+
+// lib/utils/getOrientationConstraintKeys.ts
+var getOrientationConstraintKeys = (inputProblem, label) => dedupeStrings([
+  label.netId,
+  label.globalConnNetId,
+  ...inputProblem.netConnections.filter(
+    (connection) => label.pinIds.some((pinId) => connection.pinIds.includes(pinId))
+  ).map((connection) => connection.netId)
+]);
+
+// lib/utils/normalizeFacingDirection.ts
+var normalizeFacingDirection = (value) => {
+  switch (value) {
+    case "x+":
+    case "+x":
+      return "x+";
+    case "x-":
+    case "-x":
+      return "x-";
+    case "y+":
+    case "+y":
+      return "y+";
+    case "y-":
+    case "-y":
+      return "y-";
+  }
+};
+
+// lib/utils/getOrientationConstraint.ts
+var getOrientationConstraint = (inputProblem, label) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
+  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return dedupeOrientations(
+        (availableOrientations[netId] ?? []).map(normalizeFacingDirection).filter(
+          (orientation) => orientation !== void 0
+        )
+      );
+    }
+  }
+  return null;
+};
+
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
 var EPS10 = 1e-6;
 var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
@@ -7128,26 +7190,6 @@ var createCandidate = (params) => {
     selected: false
   };
 };
-var getOrientationConstraint = (inputProblem, label) => {
-  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
-  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
-    if (Object.hasOwn(availableOrientations, netId)) {
-      return dedupeOrientations(
-        (availableOrientations[netId] ?? []).map(normalizeFacingDirection).filter(
-          (orientation) => orientation !== void 0
-        )
-      );
-    }
-  }
-  return null;
-};
-var getOrientationConstraintKeys = (inputProblem, label) => dedupeStrings([
-  label.netId,
-  label.globalConnNetId,
-  ...inputProblem.netConnections.filter(
-    (connection) => label.pinIds.some((pinId) => connection.pinIds.includes(pinId))
-  ).map((connection) => connection.netId)
-]);
 var getUnconstrainedOrientations = (params) => {
   const { label, inputProblem, point } = params;
   return dedupeOrientations([
@@ -7286,28 +7328,6 @@ var getNetLabelHeight = (inputProblem, label) => {
   )?.netLabelHeight;
 };
 var roundDistance = (distance3) => Number(distance3.toFixed(6));
-var dedupeOrientations = (orientations) => [
-  ...new Set(orientations)
-];
-var normalizeFacingDirection = (value) => {
-  switch (value) {
-    case "x+":
-    case "+x":
-      return "x+";
-    case "x-":
-    case "-x":
-      return "x-";
-    case "y+":
-    case "+y":
-      return "y+";
-    case "y-":
-    case "-y":
-      return "y-";
-  }
-};
-var dedupeStrings = (values) => [
-  ...new Set(values.filter((value) => value !== void 0))
-];
 var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS10 && Math.abs(point.y - label.anchorPoint.y) <= EPS10 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts

package/lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts

@@ -47,6 +47,17 @@ export const visualizeInputProblem = (
     }
   }
 
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    graphics.rects.push({
+      label: textBox.text ?? "schematic_text",
+      center: textBox.center,
+      width: textBox.width,
+      height: textBox.height,
+      fill: "rgba(160, 0, 220, 0.14)",
+      strokeColor: "rgba(160, 0, 220, 0.9)",
+    } as any)
+  }
+
   for (const directConn of inputProblem.directConnections) {
     const [pinId1, pinId2] = directConn.pinIds
     const pin1 = pinIdMap.get(pinId1)!

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts

@@ -5,7 +5,9 @@ import {
 } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { InputProblem } from "lib/types/InputProblem"
+import { dedupeOrientations } from "lib/utils/dedupeOrientations"
 import type { FacingDirection } from "lib/utils/dir"
+import { getOrientationConstraint } from "lib/utils/getOrientationConstraint"
 import {
   EPS,
   getManhattanDistance,
@@ -145,41 +147,6 @@ const createCandidate = (params: {
   }
 }
 
-const getOrientationConstraint = (
-  inputProblem: InputProblem,
-  label: NetLabelPlacement,
-): FacingDirection[] | null => {
-  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {}
-  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
-    if (Object.hasOwn(availableOrientations, netId)) {
-      return dedupeOrientations(
-        (availableOrientations[netId] ?? [])
-          .map(normalizeFacingDirection)
-          .filter(
-            (orientation): orientation is FacingDirection =>
-              orientation !== undefined,
-          ),
-      )
-    }
-  }
-
-  return null
-}
-
-const getOrientationConstraintKeys = (
-  inputProblem: InputProblem,
-  label: NetLabelPlacement,
-) =>
-  dedupeStrings([
-    label.netId,
-    label.globalConnNetId,
-    ...inputProblem.netConnections
-      .filter((connection) =>
-        label.pinIds.some((pinId) => connection.pinIds.includes(pinId)),
-      )
-      .map((connection) => connection.netId),
-  ])
-
 const getUnconstrainedOrientations = (params: {
   label: NetLabelPlacement
   inputProblem: InputProblem
@@ -381,33 +348,6 @@ const getNetLabelHeight = (
 
 const roundDistance = (distance: number) => Number(distance.toFixed(6))
 
-const dedupeOrientations = (orientations: FacingDirection[]) => [
-  ...new Set(orientations),
-]
-
-const normalizeFacingDirection = (
-  value: string,
-): FacingDirection | undefined => {
-  switch (value) {
-    case "x+":
-    case "+x":
-      return "x+"
-    case "x-":
-    case "-x":
-      return "x-"
-    case "y+":
-    case "+y":
-      return "y+"
-    case "y-":
-    case "-y":
-      return "y-"
-  }
-}
-
-const dedupeStrings = (values: Array<string | undefined>) => [
-  ...new Set(values.filter((value): value is string => value !== undefined)),
-]
-
 const isSamePlacement = (
   label: NetLabelPlacement,
   point: Point,

package/lib/utils/dedupeOrientations.ts

@@ -0,0 +1,5 @@
+import type { FacingDirection } from "./dir"
+
+export const dedupeOrientations = (orientations: FacingDirection[]) => [
+  ...new Set(orientations),
+]

package/lib/utils/dedupeStrings.ts

@@ -0,0 +1,3 @@
+export const dedupeStrings = (values: Array<string | undefined>) => [
+  ...new Set(values.filter((value): value is string => value !== undefined)),
+]

package/lib/utils/getOrientationConstraint.ts

@@ -0,0 +1,27 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { dedupeOrientations } from "./dedupeOrientations"
+import type { FacingDirection } from "./dir"
+import { getOrientationConstraintKeys } from "./getOrientationConstraintKeys"
+import { normalizeFacingDirection } from "./normalizeFacingDirection"
+
+export const getOrientationConstraint = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+): FacingDirection[] | null => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {}
+  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return dedupeOrientations(
+        (availableOrientations[netId] ?? [])
+          .map(normalizeFacingDirection)
+          .filter(
+            (orientation): orientation is FacingDirection =>
+              orientation !== undefined,
+          ),
+      )
+    }
+  }
+
+  return null
+}

package/lib/utils/getOrientationConstraintKeys.ts

@@ -0,0 +1,17 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import { dedupeStrings } from "./dedupeStrings"
+
+export const getOrientationConstraintKeys = (
+  inputProblem: InputProblem,
+  label: NetLabelPlacement,
+) =>
+  dedupeStrings([
+    label.netId,
+    label.globalConnNetId,
+    ...inputProblem.netConnections
+      .filter((connection) =>
+        label.pinIds.some((pinId) => connection.pinIds.includes(pinId)),
+      )
+      .map((connection) => connection.netId),
+  ])

package/lib/utils/normalizeFacingDirection.ts

@@ -0,0 +1,20 @@
+import type { FacingDirection } from "./dir"
+
+export const normalizeFacingDirection = (
+  value: string,
+): FacingDirection | undefined => {
+  switch (value) {
+    case "x+":
+    case "+x":
+      return "x+"
+    case "x-":
+    case "-x":
+      return "x-"
+    case "y+":
+    case "+y":
+      return "y+"
+    case "y-":
+    case "-y":
+      return "y-"
+  }
+}

package/package.json

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

package/site/examples/example44.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example44.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/examples/example45.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/example45.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/tests/assets/example44.json

@@ -0,0 +1,217 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 0,
+        "y": 0
+      },
+      "width": 1.3,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "PWR1.7",
+          "x": 1.05,
+          "y": 0.2
+        },
+        {
+          "pinId": "PWR1.6",
+          "x": 1.05,
+          "y": 0
+        },
+        {
+          "pinId": "PWR1.5",
+          "x": 1.05,
+          "y": -0.2
+        },
+        {
+          "pinId": "PWR1.4",
+          "x": -1.05,
+          "y": -0.30000000000000004
+        },
+        {
+          "pinId": "PWR1.3",
+          "x": -1.05,
+          "y": -0.09999999999999998
+        },
+        {
+          "pinId": "PWR1.2",
+          "x": -1.05,
+          "y": 0.10000000000000003
+        },
+        {
+          "pinId": "PWR1.1",
+          "x": -1.05,
+          "y": 0.30000000000000004
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_1",
+      "center": {
+        "x": -3,
+        "y": 0
+      },
+      "width": 1.0999999999999996,
+      "height": 0.778910699999999,
+      "pins": [
+        {
+          "pinId": "R6.1",
+          "x": -3.55,
+          "y": 0
+        },
+        {
+          "pinId": "R6.2",
+          "x": -2.45,
+          "y": 0
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_2",
+      "center": {
+        "x": -3,
+        "y": -2
+      },
+      "width": 1.0999999999999996,
+      "height": 0.7789106999999988,
+      "pins": [
+        {
+          "pinId": "R7.1",
+          "x": -3.55,
+          "y": -1.9999999999999998
+        },
+        {
+          "pinId": "R7.2",
+          "x": -2.45,
+          "y": -1.9999999999999998
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_3",
+      "center": {
+        "x": -3,
+        "y": 2
+      },
+      "width": 1.0999999999999996,
+      "height": 0.7789106999999988,
+      "pins": [
+        {
+          "pinId": "R8.1",
+          "x": -3.55,
+          "y": 2
+        },
+        {
+          "pinId": "R8.2",
+          "x": -2.45,
+          "y": 2
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_4",
+      "center": {
+        "x": 3,
+        "y": -1.5
+      },
+      "width": 1.0999999999999996,
+      "height": 1.2400000000000002,
+      "pins": [
+        {
+          "pinId": "C6.1",
+          "x": 2.45,
+          "y": -1.5
+        },
+        {
+          "pinId": "C6.2",
+          "x": 3.55,
+          "y": -1.5
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_5",
+      "center": {
+        "x": 3,
+        "y": 0
+      },
+      "width": 1.0999999999999996,
+      "height": 1.24,
+      "pins": [
+        {
+          "pinId": "C7.1",
+          "x": 2.45,
+          "y": 0
+        },
+        {
+          "pinId": "C7.2",
+          "x": 3.55,
+          "y": 0
+        }
+      ]
+    },
+    {
+      "chipId": "schematic_component_6",
+      "center": {
+        "x": 4,
+        "y": 3.1325000000000003
+      },
+      "width": 1.1299999999999994,
+      "height": 0.9150000000000005,
+      "pins": [
+        {
+          "pinId": "LED1.1",
+          "x": 3.46,
+          "y": 3
+        },
+        {
+          "pinId": "LED1.2",
+          "x": 4.54,
+          "y": 3
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "pinIds": ["R6.1", "PWR1.1"],
+      "netId": ".R6 > .pin1 to .PWR1 > .OUT"
+    },
+    {
+      "pinIds": ["LED1.1", "R8.2"],
+      "netId": ".LED1 > .pos to .R8 > .pin2"
+    },
+    {
+      "pinIds": ["PWR1.2", "R6.2"],
+      "netId": ".PWR1 > .FB to .R6 > .pin2"
+    },
+    {
+      "pinIds": ["PWR1.2", "R7.1"],
+      "netId": ".PWR1 > .FB to .R7 > .pin1"
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "gnd",
+      "pinIds": ["PWR1.7", "PWR1.3", "R7.2", "C6.2", "C7.2", "LED1.2"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "v5",
+      "pinIds": ["PWR1.6", "PWR1.4", "C6.1"],
+      "netLabelWidth": 0.36
+    },
+    {
+      "netId": "v3_3",
+      "pinIds": ["PWR1.1", "R6.1", "R8.1", "C7.1"],
+      "netLabelWidth": 0.6
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "v5": ["y+"],
+    "v3_3": ["y+"],
+    "gnd": ["y-"]
+  },
+  "maxMspPairDistance": 2.4
+}

package/tests/assets/example45.json

@@ -0,0 +1,121 @@
+{
+  "chips": [
+    {
+      "chipId": "schematic_component_0",
+      "center": {
+        "x": 7,
+        "y": 0.7
+      },
+      "width": 1,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "IC2.15",
+          "x": 7.9,
+          "y": 0.7
+        }
+      ],
+      "sectionId": "mcu"
+    },
+    {
+      "chipId": "schematic_component_19",
+      "center": {
+        "x": 11.8,
+        "y": 0.19999999999999998
+      },
+      "width": 0.7699999999999996,
+      "height": 1,
+      "pins": [
+        {
+          "pinId": "CONN1.1",
+          "x": 11.015,
+          "y": 0.5
+        },
+        {
+          "pinId": "CONN1.2",
+          "x": 11.015,
+          "y": 0.30000000000000004
+        },
+        {
+          "pinId": "CONN1.3",
+          "x": 11.015,
+          "y": 0.10000000000000003
+        },
+        {
+          "pinId": "CONN1.4",
+          "x": 11.015,
+          "y": -0.10000000000000003
+        }
+      ],
+      "sectionId": "i2c"
+    },
+    {
+      "chipId": "schematic_component_20",
+      "center": {
+        "x": 9.6,
+        "y": 0.7
+      },
+      "width": 1.1000000000000014,
+      "height": 0.7789106999999991,
+      "pins": [
+        {
+          "pinId": "R10.1",
+          "x": 9.05,
+          "y": 0.7
+        },
+        {
+          "pinId": "R10.2",
+          "x": 10.15,
+          "y": 0.7
+        }
+      ],
+      "sectionId": "i2c"
+    },
+    {
+      "chipId": "schematic_component_21",
+      "center": {
+        "x": 9.6,
+        "y": -0.3
+      },
+      "width": 1.1000000000000014,
+      "height": 0.7789106999999987,
+      "pins": [
+        {
+          "pinId": "R11.1",
+          "x": 9.05,
+          "y": -0.3
+        },
+        {
+          "pinId": "R11.2",
+          "x": 10.15,
+          "y": -0.3
+        }
+      ],
+      "sectionId": "i2c"
+    }
+  ],
+  "directConnections": [],
+  "netConnections": [
+    {
+      "netId": "V3V3",
+      "pinIds": ["CONN1.2", "R10.1", "R11.1"],
+      "netLabelWidth": 0.6
+    },
+    {
+      "netId": "SDA",
+      "pinIds": ["IC2.15", "CONN1.3", "R10.2"],
+      "netLabelWidth": 0.48
+    },
+    {
+      "netId": "SCL",
+      "pinIds": ["CONN1.4", "R11.2"],
+      "netLabelWidth": 0.48
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "V3V3": ["y+"],
+    "SDA": ["x-", "x+"],
+    "SCL": ["x-", "x+"]
+  },
+  "maxMspPairDistance": 2.4
+}