circuit-json-to-tscircuit 0.0.75 → 0.0.77

package/dist/{chunk-A65QMTEY.js → chunk-35I53U4L.js}

@@ -493,7 +493,7 @@ var isNonCollinear = ({
 // lib/generate-board-schematic-tsx/convert-symbol-primitives.ts
 import { schematic_text as schematic_text2 } from "circuit-json";
 import { applyToPoint as applyToPoint4 } from "transformation-matrix";
-var DEFAULT_SYMBOL_CIRCLE_STROKE_WIDTH = 0.02;
+var SYMBOL_OUTLINE_STROKE_WIDTH = 0.02;
 var anchors = {
   middle_top: "top_center",
   middle_bottom: "bottom_center",
@@ -518,7 +518,7 @@ var convertSymbolPrimitives = ({
     if (primitive.closed && points[0]) points.push(points[0]);
     return formatElement("schematicpath", {
       points,
-      strokeWidth: primitive.strokeWidth,
+      strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
       isFilled: primitive.fill
     });
   }
@@ -546,7 +546,7 @@ var convertSymbolPrimitives = ({
     return formatElement("schematiccircle", {
       center,
       radius: Math.hypot(radiusVector.x, radiusVector.y),
-      strokeWidth: DEFAULT_SYMBOL_CIRCLE_STROKE_WIDTH,
+      strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
       isFilled: primitive.fill
     });
   }
@@ -827,6 +827,13 @@ import { su as su4 } from "@tscircuit/soup-util";
 import { schematic_text as schematic_text3 } from "circuit-json";
 import { symbols as symbols2 } from "schematic-symbols";
 import { translate as translate3 } from "transformation-matrix";
+function canRenderNativeNetLabel(name) {
+  const selector = `net.${name}`;
+  if (/net\.[^\s>]*\./.test(selector) || /net\.[^\s>]*[+-]/.test(selector) || /net\.[0-9]/.test(selector)) {
+    return false;
+  }
+  return /^\/?[A-Za-z0-9_]+$/.test(name);
+}
 var convertNetLabels = (circuitJson) => su4(circuitJson).schematic_net_label.list().flatMap((schematicNetLabel) => {
   const anchorPosition = schematicNetLabel.anchor_position ?? schematicNetLabel.center;
   const symbolName = schematicNetLabel.symbol_name;
@@ -843,6 +850,16 @@ var convertNetLabels = (circuitJson) => su4(circuitJson).schematic_net_label.lis
         displayText: schematicNetLabel.text
       });
   }
+  if (!symbolName && schematicNetLabel.anchor_position && canRenderNativeNetLabel(schematicNetLabel.text)) {
+    return [
+      formatElement("netlabel", {
+        net: schematicNetLabel.text,
+        schX: anchorPosition.x,
+        schY: anchorPosition.y,
+        anchorSide: schematicNetLabel.anchor_side
+      })
+    ];
+  }
   return [
     formatElement("schematictext", {
       text: schematicNetLabel.text,

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-A65QMTEY.js";
+} from "../chunk-35I53U4L.js";
 
 // cli/main.ts
 import { Command } from "commander";
@@ -16,7 +16,7 @@ var package_default = {
     "./cli": "./dist/cli/main.js"
   },
   type: "module",
-  version: "0.0.74",
+  version: "0.0.76",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/dist/lib/index.js

@@ -1,6 +1,6 @@
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-A65QMTEY.js";
+} from "../chunk-35I53U4L.js";
 export {
   convertCircuitJsonToTscircuit
 };

package/lib/generate-board-schematic-tsx/convert-net-labels.ts

@@ -6,6 +6,23 @@ import type { SchematicElementConverter } from "./converter-types"
 import { convertSymbolPrimitives } from "./convert-symbol-primitives"
 import { formatElement } from "./format-attributes"
 
+// Match core's preprocessSelector checks for net names. The validator is not
+// exported by @tscircuit/core; runtime regression tests keep these in sync.
+// https://github.com/tscircuit/core/blob/main/lib/components/base-components/PrimitiveComponent/preprocessSelector.ts
+function canRenderNativeNetLabel(name: string): boolean {
+  const selector = `net.${name}`
+  if (
+    /net\.[^\s>]*\./.test(selector) ||
+    /net\.[^\s>]*[+-]/.test(selector) ||
+    /net\.[0-9]/.test(selector)
+  ) {
+    return false
+  }
+  // A label is one literal name, not a selector expression. Whitespace and CSS
+  // punctuation can parse as a different selection even when core accepts it.
+  return /^\/?[A-Za-z0-9_]+$/.test(name)
+}
+
 export const convertNetLabels: SchematicElementConverter = (circuitJson) =>
   su(circuitJson)
     .schematic_net_label.list()
@@ -26,6 +43,23 @@ export const convertNetLabels: SchematicElementConverter = (circuitJson) =>
             displayText: schematicNetLabel.text,
           })
       }
+      // Native labels own their outline, typography and anchor-side layout.
+      // Core resolves net names through selectors; retain the text fallback
+      // for names that cannot safely be used by that runtime path.
+      if (
+        !symbolName &&
+        schematicNetLabel.anchor_position &&
+        canRenderNativeNetLabel(schematicNetLabel.text)
+      ) {
+        return [
+          formatElement("netlabel", {
+            net: schematicNetLabel.text,
+            schX: anchorPosition.x,
+            schY: anchorPosition.y,
+            anchorSide: schematicNetLabel.anchor_side,
+          }),
+        ]
+      }
       return [
         formatElement("schematictext", {
           text: schematicNetLabel.text,

package/lib/generate-board-schematic-tsx/convert-symbol-primitives.ts

@@ -3,9 +3,9 @@ import type { SchSymbol } from "schematic-symbols"
 import { applyToPoint, type Matrix } from "transformation-matrix"
 import { formatElement } from "./format-attributes"
 
-// Circuit JSON symbol primitives do not encode a stroke width. This matches
-// the component outline width used by circuit-to-svg.
-const DEFAULT_SYMBOL_CIRCLE_STROKE_WIDTH = 0.02
+// circuit-to-svg renders library symbol paths and circles with a fixed
+// component outline width, independent of library strokeWidth and symbol scale.
+const SYMBOL_OUTLINE_STROKE_WIDTH = 0.02
 
 const anchors = {
   middle_top: "top_center",
@@ -38,7 +38,7 @@ export const convertSymbolPrimitives = ({
       if (primitive.closed && points[0]) points.push(points[0])
       return formatElement("schematicpath", {
         points,
-        strokeWidth: primitive.strokeWidth,
+        strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
         isFilled: primitive.fill,
       })
     }
@@ -72,7 +72,7 @@ export const convertSymbolPrimitives = ({
       return formatElement("schematiccircle", {
         center,
         radius: Math.hypot(radiusVector.x, radiusVector.y),
-        strokeWidth: DEFAULT_SYMBOL_CIRCLE_STROKE_WIDTH,
+        strokeWidth: SYMBOL_OUTLINE_STROKE_WIDTH,
         isFilled: primitive.fill,
       })
     }

package/package.json

@@ -6,7 +6,7 @@
     "./cli": "./dist/cli/main.js"
   },
   "type": "module",
-  "version": "0.0.75",
+  "version": "0.0.77",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/tests/board-net-label-name-validation.test.ts

@@ -0,0 +1,86 @@
+import { expect, test } from "bun:test"
+import { convertNetLabels } from "../lib/generate-board-schematic-tsx/convert-net-labels"
+import { runTscircuitCode } from "tscircuit"
+
+function convertPlainNetLabel(text: string) {
+  return convertNetLabels([
+    {
+      type: "schematic_net_label",
+      schematic_net_label_id: "label",
+      source_net_id: "net",
+      text,
+      center: { x: 2, y: 3 },
+      anchor_position: { x: 2, y: 3 },
+      anchor_side: "left",
+    },
+  ]).join("\n")
+}
+
+for (const name of ["VCC-P", "VCC+P", "3V3", "1", "-VCC", "net.name"]) {
+  test(`conversion preserves text when core rejects ${name}`, async () => {
+    await expect(
+      runTscircuitCode(
+        `export default () => <board><netlabel net={${JSON.stringify(name)}} /></board>`,
+      ),
+    ).rejects.toThrow(/Net name/)
+    const generated = convertPlainNetLabel(name)
+    expect(generated).not.toContain("<netlabel")
+    const output = await runTscircuitCode(
+      `export default () => <board><symbol>${generated}</symbol></board>`,
+    )
+    expect(output).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "schematic_text", text: name }),
+      ]),
+    )
+  })
+}
+
+for (const name of ["SDA", "V3_3", "_RESET", "/RESET", "/3V3", "A1"]) {
+  test(`conversion preserves native labels accepted by core: ${name}`, async () => {
+    const source = await runTscircuitCode(
+      `export default () => <board><netlabel net={${JSON.stringify(name)}} schX={2} schY={3} anchorSide="left" /></board>`,
+    )
+    const generated = convertNetLabels(source).join("\n")
+    expect(generated).toContain("<netlabel")
+    const output = await runTscircuitCode(
+      `export default () => <board><symbol>${generated}</symbol></board>`,
+    )
+    expect(output).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "schematic_net_label",
+          text: name,
+          anchor_position: { x: 2, y: 3 },
+          anchor_side: "left",
+        }),
+      ]),
+    )
+  })
+}
+
+for (const name of [
+  "BUS/DATA",
+  "//RESET",
+  "HV VSYS",
+  "A>B",
+  "A,B",
+  "A[1]",
+  "A:B",
+  'A"B',
+  "",
+  "電源",
+]) {
+  test(`conversion preserves selector-unsafe label text: ${name}`, async () => {
+    const generated = convertPlainNetLabel(name)
+    expect(generated).not.toContain("<netlabel")
+    const output = await runTscircuitCode(
+      `export default () => <board><symbol>${generated}</symbol></board>`,
+    )
+    expect(output).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "schematic_text", text: name }),
+      ]),
+    )
+  })
+}

package/tests/board-plain-net-label-anchor.test.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "bun:test"
+import type { CircuitJson } from "circuit-json"
+import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg"
+import { convertCircuitJsonToTscircuit } from "lib"
+import { runTscircuitCode } from "tscircuit"
+
+test("native plain labels preserve rendering on every connection side", async () => {
+  for (const side of ["left", "right", "top", "bottom"] as const) {
+    const input = await runTscircuitCode(`export default () => (
+      <board width={10} height={10}>
+        <netlabel net="DATA" schX={2} schY={3} anchorSide="${side}" />
+      </board>
+    )`)
+    const output = await runTscircuitCode(
+      convertCircuitJsonToTscircuit(input, { componentName: "LabelBoard" }),
+    )
+    const sourceLabels = input.filter((e) => e.type === "schematic_net_label")
+    const renderedLabels = output.filter(
+      (e) => e.type === "schematic_net_label",
+    )
+    expect(renderedLabels).toHaveLength(1)
+    const original = sourceLabels[0]!
+    expect(renderedLabels[0]).toMatchObject({
+      text: original.text,
+      anchor_side: original.anchor_side,
+      anchor_position: original.anchor_position,
+      center: original.center,
+    })
+    expect(
+      convertCircuitJsonToSchematicSvg(renderedLabels, {
+        includeVersion: false,
+      }),
+    ).toBe(
+      convertCircuitJsonToSchematicSvg(sourceLabels, { includeVersion: false }),
+    )
+  }
+  for (const name of [
+    "HV VSYS",
+    "BUS/DATA",
+    "net.name",
+    "",
+    'A"B',
+    "CENTER_ONLY",
+    "VCC-P",
+    "VCC+P",
+    "3V3",
+    "1",
+    "-VCC",
+  ]) {
+    const input: CircuitJson = [
+      {
+        type: "pcb_board",
+        pcb_board_id: "board",
+        center: { x: 0, y: 0 },
+        width: 10,
+        height: 10,
+        num_layers: 2,
+        thickness: 1.6,
+        material: "fr4",
+      },
+      {
+        type: "schematic_net_label",
+        schematic_net_label_id: "label",
+        text: name,
+        center: { x: 2, y: 3 },
+        anchor_position: name === "CENTER_ONLY" ? undefined : { x: 2, y: 3 },
+        anchor_side: "left",
+        source_net_id: "net",
+      },
+    ]
+    const tsx = convertCircuitJsonToTscircuit(input, {
+      componentName: "Fallback",
+    })
+    expect(tsx).not.toContain("<netlabel")
+    const fallback = await runTscircuitCode(tsx)
+    expect(fallback).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: "schematic_text", text: name }),
+      ]),
+    )
+  }
+})

package/tests/board-symbol-outline-width.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import { gunzipSync } from "node:zlib"
+import type { CircuitJson } from "circuit-json"
+import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg"
+import { convertCircuitJsonToTscircuit } from "lib"
+import { runTscircuitCode } from "tscircuit"
+import { applyToPoint, compose, scale, translate } from "transformation-matrix"
+
+// Compare stroke/segment-length ratios so SVG auto-fit does not affect the test.
+const firstPathStrokeRatio = (svg: string) => {
+  const path = svg.match(/<path\b[^>]*\bd="M ([^\"]+)"[^>]*>/)?.[0]
+  if (!path) throw new Error("Missing rendered symbol path")
+  const coordinates = path
+    .match(/\bd="M ([^\"]+)"/)![1]!
+    .split(/[MLZ\s,]+/)
+    .filter(Boolean)
+    .map(Number)
+  const width = Number.parseFloat(path.match(/\bstroke-width="([^\"]+)"/)![1]!)
+  return (
+    width /
+    Math.hypot(
+      coordinates[2]! - coordinates[0]!,
+      coordinates[3]! - coordinates[1]!,
+    )
+  )
+}
+
+for (const [fixture, symbolName, scaleFactor] of [
+  ["drv8307evm", "boxresistor_up", 1],
+  ["lm251772evm-pd", "boxresistor_right", 2],
+  ["lm5155evm-fly", "capacitor_down", 0.5],
+  ["lmg342x-bb-evm", "capacitor_polarized_down", 1],
+  ["drv8307evm", "diode_down", 1],
+] as const) {
+  test(`${fixture} ${symbolName} keeps rendered outline width at scale ${scaleFactor}`, async () => {
+    const source = JSON.parse(
+      gunzipSync(
+        readFileSync(
+          new URL(
+            `./fixtures/ti-evms/${fixture}.circuit.json.gz`,
+            import.meta.url,
+          ),
+        ),
+      ).toString(),
+    ) as CircuitJson
+    const component = source.find(
+      (e) => e.type === "schematic_component" && e.symbol_name === symbolName,
+    )
+    if (component?.type !== "schematic_component")
+      throw new Error("Missing fixture symbol")
+    const subset = source.filter(
+      (e) =>
+        e.type === "pcb_board" ||
+        e === component ||
+        (e.type === "source_component" &&
+          e.source_component_id === component.source_component_id) ||
+        (e.type === "source_port" &&
+          e.source_component_id === component.source_component_id) ||
+        (e.type === "schematic_port" &&
+          e.schematic_component_id === component.schematic_component_id),
+    )
+    const schematicToScaledSchematicTransform = compose(
+      translate(component.center.x, component.center.y),
+      scale(scaleFactor),
+      translate(-component.center.x, -component.center.y),
+    )
+    const scaledSize = applyToPoint(scale(scaleFactor), {
+      x: component.size.width,
+      y: component.size.height,
+    })
+    component.size = { width: scaledSize.x, height: scaledSize.y }
+    for (const element of subset) {
+      if (element.type === "schematic_port") {
+        element.center = applyToPoint(
+          schematicToScaledSchematicTransform,
+          element.center,
+        )
+      }
+    }
+    const output = await runTscircuitCode(
+      convertCircuitJsonToTscircuit(subset, { componentName: "SymbolOutline" }),
+    )
+    expect(
+      firstPathStrokeRatio(convertCircuitJsonToSchematicSvg(output)),
+    ).toBeCloseTo(
+      firstPathStrokeRatio(convertCircuitJsonToSchematicSvg(subset)),
+      8,
+    )
+  })
+}