circuit-json-to-lbrn 0.0.1 → 0.0.3

package/.github/workflows/bun-formatcheck.yml

@@ -0,0 +1,26 @@
+# Created using @tscircuit/plop (npm install -g @tscircuit/plop)
+name: Format Check
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  format-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run format check
+        run: bun run format:check

package/.github/workflows/bun-pver-release.yml

@@ -0,0 +1,71 @@
+# Created using @tscircuit/plop (npm install -g @tscircuit/plop)
+name: Publish to npm
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+env:
+  UPSTREAM_REPOS: "" # comma-separated list, e.g. "eval,tscircuit,docs"
+  UPSTREAM_PACKAGES_TO_UPDATE: "" # comma-separated list, e.g. "@tscircuit/core,@tscircuit/protos"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    if: ${{ !(github.event_name == 'push' && startsWith(github.event.head_commit.message, 'v')) }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}
+      - name: Setup bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm install -g pver
+      - run: bun install --frozen-lockfile
+      - run: bun run build
+      - run: pver release --no-push-main
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}
+
+      - name: Create Pull Request
+        id: create-pr
+        uses: peter-evans/create-pull-request@v5
+        with:
+          commit-message: "chore: bump version"
+          title: "chore: bump version"
+          body: "Automated package update"
+          branch: bump-version-${{ github.run_number }}
+          base: main
+          token: ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}
+          committer: tscircuitbot <githubbot@tscircuit.com>
+          author: tscircuitbot <githubbot@tscircuit.com>
+
+      - name: Enable auto-merge
+        if: steps.create-pr.outputs.pull-request-number != ''
+        run: |
+          gh pr merge ${{ steps.create-pr.outputs.pull-request-number }} --auto --squash --delete-branch
+        env:
+          GH_TOKEN: ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}
+
+      # - name: Trigger upstream repo updates
+      #   if: env.UPSTREAM_REPOS && env.UPSTREAM_PACKAGES_TO_UPDATE
+      #   run: |
+      #     IFS=',' read -ra REPOS <<< "${{ env.UPSTREAM_REPOS }}"
+      #     for repo in "${REPOS[@]}"; do
+      #       if [[ -n "$repo" ]]; then
+      #         echo "Triggering update for repo: $repo"
+      #         curl -X POST \
+      #           -H "Accept: application/vnd.github.v3+json" \
+      #           -H "Authorization: token ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}" \
+      #           -H "Content-Type: application/json" \
+      #           "https://api.github.com/repos/tscircuit/$repo/actions/workflows/update-package.yml/dispatches" \
+      #           -d "{\"ref\":\"main\",\"inputs\":{\"package_names\":\"${{ env.UPSTREAM_PACKAGES_TO_UPDATE }}\"}}"
+      #       fi
+      #     done

package/.github/workflows/bun-test.yml

@@ -0,0 +1,31 @@
+# Created using @tscircuit/plop (npm install -g @tscircuit/plop)
+name: Bun Test
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    # Skip test for PRs that not chore: bump version
+    if: "${{ github.event_name != 'pull_request' || github.event.pull_request.title != 'chore: bump version' }}"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.1
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run tests
+        run: bun test

package/.github/workflows/bun-typecheck.yml

@@ -0,0 +1,26 @@
+# Created using @tscircuit/plop (npm install -g @tscircuit/plop)
+name: Type Check
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  type-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun i
+
+      - name: Run type check
+        run: bunx tsc --noEmit

package/dist/index.d.ts

@@ -3,6 +3,10 @@ import { LightBurnProject } from 'lbrnts';
 
 declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: {
     includeSilkscreen?: boolean;
+    origin?: {
+        x: number;
+        y: number;
+    };
 }) => LightBurnProject;
 
 export { convertCircuitJsonToLbrn };

package/dist/index.js

@@ -1,172 +1,27 @@
 // lib/index.ts
-import { LightBurnProject, CutSetting } from "lbrnts";
+import { LightBurnProject, CutSetting, ShapePath as ShapePath3 } from "lbrnts";
 import { cju } from "@tscircuit/circuit-json-util";
 
 // lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
 import { ShapePath } from "lbrnts";
-var addCirclePlatedHole = (platedHole, ctx) => {
-  const { project, copperCutSetting } = ctx;
-  const radius = platedHole.outer_diameter / 2;
-  const centerX = platedHole.x;
-  const centerY = platedHole.y;
-  const kappa = 0.5522847498;
-  const controlOffset = radius * kappa;
-  const verts = [
-    // Right point (3 o'clock)
-    { x: centerX + radius, y: centerY },
-    // Bottom point (6 o'clock) with control points
-    {
-      x: centerX,
-      y: centerY + radius,
-      c: 1,
-      c0x: radius,
-      c0y: controlOffset,
-      c1x: controlOffset,
-      c1y: radius
-    },
-    // Left point (9 o'clock) with control points
-    {
-      x: centerX - radius,
-      y: centerY,
-      c: 1,
-      c0x: -controlOffset,
-      c0y: radius,
-      c1x: -radius,
-      c1y: controlOffset
-    },
-    // Top point (12 o'clock) with control points
-    {
-      x: centerX,
-      y: centerY - radius,
-      c: 1,
-      c0x: -radius,
-      c0y: -controlOffset,
-      c1x: -controlOffset,
-      c1y: -radius
-    },
-    // Back to right point (close path) with control points
-    {
-      x: centerX + radius,
-      y: centerY,
-      c: 1,
-      c0x: controlOffset,
-      c0y: -radius,
-      c1x: radius,
-      c1y: -controlOffset
-    }
-  ];
-  const prims = [
-    { type: 1 },
-    // BezierTo for bottom
-    { type: 1 },
-    // BezierTo for left
-    { type: 1 },
-    // BezierTo for top
-    { type: 1 }
-    // BezierTo for right (closing)
-  ];
-  project.children.push(
-    new ShapePath({
-      cutIndex: copperCutSetting.index,
-      verts,
-      prims,
-      isClosed: true
-    })
-  );
-};
-
-// lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts
-var addOvalPlatedHole = (platedHole, ctx) => {
-  console.warn(
-    `Oval/pill plated hole not yet implemented: ${platedHole.pcb_plated_hole_id}`
-  );
-};
-
-// lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts
-var addCircularHoleWithRectPad = (platedHole, ctx) => {
-  console.warn(
-    `Circular hole with rect pad not yet implemented: ${platedHole.pcb_plated_hole_id}`
-  );
-};
-
-// lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts
-var addPillHoleWithRectPad = (platedHole, ctx) => {
-  console.warn(
-    `Pill hole with rect pad not yet implemented: ${platedHole.pcb_plated_hole_id}`
-  );
-};
-
-// lib/element-handlers/addPlatedHole/addRotatedPillHoleWithRectPad.ts
-var addRotatedPillHoleWithRectPad = (platedHole, ctx) => {
-  console.warn(
-    `Rotated pill hole with rect pad not yet implemented: ${platedHole.pcb_plated_hole_id}`
-  );
-};
-
-// lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts
-var addHoleWithPolygonPad = (platedHole, ctx) => {
-  console.warn(
-    `Hole with polygon pad not yet implemented: ${platedHole.pcb_plated_hole_id}`
-  );
-};
-
-// lib/element-handlers/addPlatedHole/index.ts
-var addPlatedHole = (platedHole, ctx) => {
-  switch (platedHole.shape) {
-    case "circle":
-      return addCirclePlatedHole(platedHole, ctx);
-    case "oval":
-    case "pill":
-      return addOvalPlatedHole(platedHole, ctx);
-    case "circular_hole_with_rect_pad":
-      return addCircularHoleWithRectPad(platedHole, ctx);
-    case "pill_hole_with_rect_pad":
-      return addPillHoleWithRectPad(platedHole, ctx);
-    case "rotated_pill_hole_with_rect_pad":
-      return addRotatedPillHoleWithRectPad(platedHole, ctx);
-    case "hole_with_polygon_pad":
-      return addHoleWithPolygonPad(platedHole, ctx);
-    default:
-      const _exhaustive = platedHole;
-      console.warn(`Unknown plated hole shape: ${platedHole.shape}`);
-  }
-};
 
 // lib/element-handlers/addSmtPad/addRectSmtPad.ts
-import { ShapePath as ShapePath2 } from "lbrnts";
+import { Box } from "@flatten-js/core";
+import "lbrnts";
 var addRectSmtPad = (smtPad, ctx) => {
-  const { project, copperCutSetting } = ctx;
-  const centerX = smtPad.x;
-  const centerY = smtPad.y;
+  const { project, copperCutSetting, connMap, netGeoms, origin } = ctx;
+  const centerX = smtPad.x + origin.x;
+  const centerY = smtPad.y + origin.y;
   const halfWidth = smtPad.width / 2;
   const halfHeight = smtPad.height / 2;
-  const verts = [
-    { x: centerX - halfWidth, y: centerY - halfHeight },
-    // Top-left
-    { x: centerX + halfWidth, y: centerY - halfHeight },
-    // Top-right
-    { x: centerX + halfWidth, y: centerY + halfHeight },
-    // Bottom-right
-    { x: centerX - halfWidth, y: centerY + halfHeight }
-    // Bottom-left
-  ];
-  const prims = [
-    { type: 0 },
-    // LineTo for top-right
-    { type: 0 },
-    // LineTo for bottom-right
-    { type: 0 },
-    // LineTo for bottom-left
-    { type: 0 }
-    // LineTo back to top-left (closing)
-  ];
-  project.children.push(
-    new ShapePath2({
-      cutIndex: copperCutSetting.index,
-      verts,
-      prims,
-      isClosed: true
-    })
+  const netId = connMap.getNetConnectedToId(smtPad.pcb_smtpad_id);
+  ctx.netGeoms.get(netId)?.push(
+    new Box(
+      centerX - halfWidth,
+      centerY - halfHeight,
+      centerX + halfWidth,
+      centerY + halfHeight
+    )
   );
 };
 
@@ -183,6 +38,116 @@ var addSmtPad = (smtPad, ctx) => {
   }
 };
 
+// lib/element-handlers/addPcbTrace/index.ts
+import Flatten2, { BooleanOperations } from "@flatten-js/core";
+
+// lib/element-handlers/addPcbTrace/circle-to-polygon.ts
+import Flatten from "@flatten-js/core";
+var circleToPolygon = (circle, segments = 32) => {
+  const points = [];
+  for (let i = 0; i < segments; i++) {
+    const angle = i * 2 * Math.PI / segments;
+    const x = circle.center.x + circle.r * Math.cos(angle);
+    const y = circle.center.y + circle.r * Math.sin(angle);
+    points.push(Flatten.point(x, y));
+  }
+  return new Flatten.Polygon(points);
+};
+
+// lib/element-handlers/addPcbTrace/index.ts
+var addPcbTrace = (trace, ctx) => {
+  const { netGeoms, connMap, origin } = ctx;
+  const netId = connMap.getNetConnectedToId(
+    trace.source_trace_id ?? trace.pcb_trace_id
+  );
+  if (!netId) {
+    console.warn(`Trace ${trace.pcb_trace_id} is not connected to any net`);
+    return;
+  }
+  if (!trace.route || trace.route.length < 2) {
+    console.warn(`Trace ${trace.pcb_trace_id} has insufficient route points`);
+    return;
+  }
+  const { route } = trace;
+  const traceWidth = route.find((point) => point.route_type === "wire")?.width ?? 0.15;
+  const polygons = [];
+  for (const routePoint of route) {
+    const circle = new Flatten2.Circle(
+      new Flatten2.Point(routePoint.x + origin.x, routePoint.y + origin.y),
+      traceWidth / 2
+    );
+    polygons.push(circleToPolygon(circle));
+  }
+  for (let i = 0; i < route.length - 1; i++) {
+    const p1 = route[i];
+    const p2 = route[i + 1];
+    if (!p1 || !p2) continue;
+    const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
+    if (segmentLength === 0) continue;
+    const centerX = (p1.x + p2.x) / 2 + origin.x;
+    const centerY = (p1.y + p2.y) / 2 + origin.y;
+    const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
+    const w2 = segmentLength / 2;
+    const h2 = traceWidth / 2;
+    const angleRad = rotationDeg * Math.PI / 180;
+    const cosAngle = Math.cos(angleRad);
+    const sinAngle = Math.sin(angleRad);
+    const corners = [
+      { x: -w2, y: -h2 },
+      { x: w2, y: -h2 },
+      { x: w2, y: h2 },
+      { x: -w2, y: h2 }
+    ];
+    const rotatedCorners = corners.map((p) => ({
+      x: centerX + p.x * cosAngle - p.y * sinAngle,
+      y: centerY + p.x * sinAngle + p.y * cosAngle
+    }));
+    polygons.push(
+      new Flatten2.Polygon(rotatedCorners.map((p) => Flatten2.point(p.x, p.y)))
+    );
+  }
+  if (polygons.length === 0) return;
+  let tracePolygon = polygons[0];
+  for (let i = 1; i < polygons.length; i++) {
+    const poly = polygons[i];
+    if (poly) {
+      tracePolygon = BooleanOperations.unify(tracePolygon, poly);
+    }
+  }
+  netGeoms.get(netId)?.push(tracePolygon);
+};
+
+// lib/index.ts
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import { Polygon, Box as Box2, BooleanOperations as BooleanOperations2 } from "@flatten-js/core";
+
+// lib/polygon-to-shape-path.ts
+function polygonToShapePathData(polygon) {
+  const verts = [];
+  const prims = [];
+  const svgString = polygon.svg();
+  const dAttributeMatch = svgString.match(/\bd="([^"]+)"/);
+  if (!dAttributeMatch || !dAttributeMatch[1]) {
+    return { verts, prims };
+  }
+  const pathData = dAttributeMatch[1].trim();
+  const commands = pathData.match(/[MLz][^MLz]*/g) || [];
+  for (const command of commands) {
+    const type = command[0];
+    const coords = command.slice(1).trim();
+    if (type === "M" || type === "L") {
+      const parts = coords.split(",");
+      const x = Number(parts[0]);
+      const y = Number(parts[1]);
+      if (!Number.isNaN(x) && !Number.isNaN(y)) {
+        verts.push({ x, y });
+        prims.push({ type: 0 });
+      }
+    }
+  }
+  return { verts, prims };
+}
+
 // lib/index.ts
 var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   const db = cju(circuitJson);
@@ -197,16 +162,51 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     speed: 100
   });
   project.children.push(copperCutSetting);
+  const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
   const ctx = {
     db,
     project,
-    copperCutSetting
+    copperCutSetting,
+    connMap,
+    netGeoms: /* @__PURE__ */ new Map(),
+    origin: options.origin ?? { x: 0, y: 0 }
   };
+  for (const net of Object.keys(connMap.netMap)) {
+    ctx.netGeoms.set(net, []);
+  }
   for (const smtpad of db.pcb_smtpad.list()) {
     addSmtPad(smtpad, ctx);
   }
-  for (const platedHole of db.pcb_plated_hole.list()) {
-    addPlatedHole(platedHole, ctx);
+  for (const trace of db.pcb_trace.list()) {
+    addPcbTrace(trace, ctx);
+  }
+  for (const net of Object.keys(connMap.netMap)) {
+    const netGeoms = ctx.netGeoms.get(net);
+    if (netGeoms.length === 0) {
+      continue;
+    }
+    let union = netGeoms[0];
+    if (union instanceof Box2) {
+      union = new Polygon(union);
+    }
+    for (const geom of netGeoms.slice(1)) {
+      if (geom instanceof Polygon) {
+        union = BooleanOperations2.unify(union, geom);
+      } else if (geom instanceof Box2) {
+        union = BooleanOperations2.unify(union, new Polygon(geom));
+      }
+    }
+    for (const island of union.splitToIslands()) {
+      const { verts, prims } = polygonToShapePathData(island);
+      project.children.push(
+        new ShapePath3({
+          cutIndex: copperCutSetting.index,
+          verts,
+          prims,
+          isClosed: false
+        })
+      );
+    }
   }
   return project;
 };

package/lib/ConvertContext.ts

@@ -1,9 +1,19 @@
 import type { CircuitJsonUtilObjects } from "@tscircuit/circuit-json-util"
 import type { CutSetting, LightBurnProject } from "lbrnts"
+import type { AnyShape, Box, Polygon } from "@flatten-js/core"
+import type { ConnectivityMap } from "circuit-json-to-connectivity-map"
+
+export type ConnectivityMapKey = string
 
 export interface ConvertContext {
   db: CircuitJsonUtilObjects
   project: LightBurnProject
 
   copperCutSetting: CutSetting
+
+  connMap: ConnectivityMap
+
+  netGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
+
+  origin: { x: number; y: number }
 }

package/lib/element-handlers/addPcbTrace/circle-to-polygon.ts

@@ -0,0 +1,15 @@
+import Flatten from "@flatten-js/core"
+
+export const circleToPolygon = (
+  circle: Flatten.Circle,
+  segments = 32,
+): Flatten.Polygon => {
+  const points: Flatten.Point[] = []
+  for (let i = 0; i < segments; i++) {
+    const angle = (i * 2 * Math.PI) / segments
+    const x = circle.center.x + circle.r * Math.cos(angle)
+    const y = circle.center.y + circle.r * Math.sin(angle)
+    points.push(Flatten.point(x, y))
+  }
+  return new Flatten.Polygon(points)
+}

package/lib/element-handlers/addPcbTrace/index.ts

@@ -0,0 +1,90 @@
+import type { PcbTrace } from "circuit-json"
+import type { ConvertContext } from "../../ConvertContext"
+import Flatten, { BooleanOperations } from "@flatten-js/core"
+import { circleToPolygon } from "./circle-to-polygon"
+
+export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
+  const { netGeoms, connMap, origin } = ctx
+
+  const netId = connMap.getNetConnectedToId(
+    trace.source_trace_id ?? trace.pcb_trace_id,
+  )!
+
+  if (!netId) {
+    console.warn(`Trace ${trace.pcb_trace_id} is not connected to any net`)
+    return
+  }
+
+  if (!trace.route || trace.route.length < 2) {
+    console.warn(`Trace ${trace.pcb_trace_id} has insufficient route points`)
+    return
+  }
+
+  const { route } = trace
+
+  const traceWidth =
+    route.find((point) => point.route_type === "wire")?.width ?? 0.15
+
+  const polygons: Flatten.Polygon[] = []
+
+  // Add circles for each vertex
+  for (const routePoint of route) {
+    const circle = new Flatten.Circle(
+      new Flatten.Point(routePoint.x + origin.x, routePoint.y + origin.y),
+      traceWidth / 2,
+    )
+    polygons.push(circleToPolygon(circle))
+  }
+
+  // Add rectangles for each segment
+  for (let i = 0; i < route.length - 1; i++) {
+    const p1 = route[i]
+    const p2 = route[i + 1]
+
+    if (!p1 || !p2) continue
+
+    const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y)
+    if (segmentLength === 0) continue
+
+    const centerX = (p1.x + p2.x) / 2 + origin.x
+    const centerY = (p1.y + p2.y) / 2 + origin.y
+    const rotationDeg = (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI
+
+    const w2 = segmentLength / 2
+    const h2 = traceWidth / 2
+
+    const angleRad = (rotationDeg * Math.PI) / 180
+    const cosAngle = Math.cos(angleRad)
+    const sinAngle = Math.sin(angleRad)
+
+    const corners = [
+      { x: -w2, y: -h2 },
+      { x: w2, y: -h2 },
+      { x: w2, y: h2 },
+      { x: -w2, y: h2 },
+    ]
+
+    const rotatedCorners = corners.map((p) => ({
+      x: centerX + p.x * cosAngle - p.y * sinAngle,
+      y: centerY + p.x * sinAngle + p.y * cosAngle,
+    }))
+
+    polygons.push(
+      new Flatten.Polygon(rotatedCorners.map((p) => Flatten.point(p.x, p.y))),
+    )
+  }
+
+  // Union all polygons together to create the final trace polygon
+  if (polygons.length === 0) return
+
+  let tracePolygon = polygons[0]!
+
+  for (let i = 1; i < polygons.length; i++) {
+    const poly = polygons[i]
+    if (poly) {
+      tracePolygon = BooleanOperations.unify(tracePolygon, poly)
+    }
+  }
+
+  netGeoms.get(netId)?.push(tracePolygon)
+}