circuit-json-to-tscircuit 0.0.75 → 0.0.76

package/dist/{chunk-A65QMTEY.js → chunk-NQTXLCEN.js}

@@ -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-NQTXLCEN.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.75",
   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-NQTXLCEN.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/package.json

@@ -6,7 +6,7 @@
     "./cli": "./dist/cli/main.js"
   },
   "type": "module",
-  "version": "0.0.75",
+  "version": "0.0.76",
   "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 }),
+      ]),
+    )
+  }
+})