circuit-json-to-lbrn 0.0.16 → 0.0.18

package/dist/index.js

@@ -1,5 +1,5 @@
 // lib/index.ts
-import { LightBurnProject, CutSetting, ShapePath as ShapePath16 } from "lbrnts";
+import { LightBurnProject, CutSetting, ShapePath as ShapePath25 } from "lbrnts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
 
 // lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
@@ -1436,6 +1436,476 @@ var addPcbVia = (via, ctx) => {
   }
 };
 
+// lib/element-handlers/addPcbHole/addCirclePcbHole.ts
+import { ShapePath as ShapePath16 } from "lbrnts";
+var addCirclePcbHole = (hole, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    soldermaskCutSetting,
+    origin,
+    includeSoldermask,
+    soldermaskMargin
+  } = ctx;
+  const centerX = hole.x + origin.x;
+  const centerY = hole.y + origin.y;
+  if (hole.hole_diameter > 0 && includeSoldermask) {
+    const smRadius = hole.hole_diameter / 2 + soldermaskMargin;
+    const soldermaskPath = createCirclePath(centerX, centerY, smRadius);
+    project.children.push(
+      new ShapePath16({
+        cutIndex: soldermaskCutSetting.index,
+        verts: soldermaskPath.verts,
+        prims: soldermaskPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (hole.hole_diameter > 0) {
+    const radius = hole.hole_diameter / 2;
+    const circlePath = createCirclePath(centerX, centerY, radius);
+    project.children.push(
+      new ShapePath16({
+        cutIndex: throughBoardCutSetting.index,
+        verts: circlePath.verts,
+        prims: circlePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbHole/addRectPcbHole.ts
+import { ShapePath as ShapePath17 } from "lbrnts";
+var addRectPcbHole = (hole, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    soldermaskCutSetting,
+    origin,
+    includeSoldermask,
+    soldermaskMargin
+  } = ctx;
+  const centerX = hole.x + origin.x;
+  const centerY = hole.y + origin.y;
+  if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
+    const soldermaskPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      hole.hole_width + soldermaskMargin * 2,
+      hole.hole_height + soldermaskMargin * 2,
+      0
+      // no border radius for rect holes
+    );
+    project.children.push(
+      new ShapePath17({
+        cutIndex: soldermaskCutSetting.index,
+        verts: soldermaskPath.verts,
+        prims: soldermaskPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (hole.hole_width > 0 && hole.hole_height > 0) {
+    const rectPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      hole.hole_width,
+      hole.hole_height,
+      0
+      // no border radius for rect holes
+    );
+    project.children.push(
+      new ShapePath17({
+        cutIndex: throughBoardCutSetting.index,
+        verts: rectPath.verts,
+        prims: rectPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbHole/addOvalPcbHole.ts
+import { ShapePath as ShapePath18 } from "lbrnts";
+var addOvalPcbHole = (hole, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    soldermaskCutSetting,
+    origin,
+    includeSoldermask,
+    soldermaskMargin
+  } = ctx;
+  const centerX = hole.x + origin.x;
+  const centerY = hole.y + origin.y;
+  if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
+    const soldermaskPath = createOvalPath(
+      centerX,
+      centerY,
+      hole.hole_width + soldermaskMargin * 2,
+      hole.hole_height + soldermaskMargin * 2
+    );
+    project.children.push(
+      new ShapePath18({
+        cutIndex: soldermaskCutSetting.index,
+        verts: soldermaskPath.verts,
+        prims: soldermaskPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (hole.hole_width > 0 && hole.hole_height > 0) {
+    const ovalPath = createOvalPath(
+      centerX,
+      centerY,
+      hole.hole_width,
+      hole.hole_height
+    );
+    project.children.push(
+      new ShapePath18({
+        cutIndex: throughBoardCutSetting.index,
+        verts: ovalPath.verts,
+        prims: ovalPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbHole/addPillPcbHole.ts
+import { ShapePath as ShapePath19 } from "lbrnts";
+var addPillPcbHole = (hole, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    soldermaskCutSetting,
+    origin,
+    includeSoldermask,
+    soldermaskMargin
+  } = ctx;
+  const centerX = hole.x + origin.x;
+  const centerY = hole.y + origin.y;
+  if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
+    const soldermaskPath = createPillPath(
+      centerX,
+      centerY,
+      hole.hole_width + soldermaskMargin * 2,
+      hole.hole_height + soldermaskMargin * 2
+    );
+    project.children.push(
+      new ShapePath19({
+        cutIndex: soldermaskCutSetting.index,
+        verts: soldermaskPath.verts,
+        prims: soldermaskPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (hole.hole_width > 0 && hole.hole_height > 0) {
+    const pillPath = createPillPath(
+      centerX,
+      centerY,
+      hole.hole_width,
+      hole.hole_height
+    );
+    project.children.push(
+      new ShapePath19({
+        cutIndex: throughBoardCutSetting.index,
+        verts: pillPath.verts,
+        prims: pillPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbHole/addRotatedPillPcbHole.ts
+import { ShapePath as ShapePath20 } from "lbrnts";
+var addRotatedPillPcbHole = (hole, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    soldermaskCutSetting,
+    origin,
+    includeSoldermask,
+    soldermaskMargin
+  } = ctx;
+  const centerX = hole.x + origin.x;
+  const centerY = hole.y + origin.y;
+  const rotation = (hole.ccw_rotation || 0) * (Math.PI / 180);
+  if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
+    const soldermaskPath = createPillPath(
+      centerX,
+      centerY,
+      hole.hole_width + soldermaskMargin * 2,
+      hole.hole_height + soldermaskMargin * 2,
+      rotation
+    );
+    project.children.push(
+      new ShapePath20({
+        cutIndex: soldermaskCutSetting.index,
+        verts: soldermaskPath.verts,
+        prims: soldermaskPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (hole.hole_width > 0 && hole.hole_height > 0) {
+    const pillPath = createPillPath(
+      centerX,
+      centerY,
+      hole.hole_width,
+      hole.hole_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath20({
+        cutIndex: throughBoardCutSetting.index,
+        verts: pillPath.verts,
+        prims: pillPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbHole/index.ts
+var addPcbHole = (hole, ctx) => {
+  switch (hole.hole_shape) {
+    case "circle":
+    case "square":
+      return addCirclePcbHole(hole, ctx);
+    case "rect":
+      return addRectPcbHole(hole, ctx);
+    case "oval":
+      return addOvalPcbHole(hole, ctx);
+    case "pill":
+      return addPillPcbHole(hole, ctx);
+    case "rotated_pill":
+      return addRotatedPillPcbHole(hole, ctx);
+    default:
+      const _exhaustive = hole;
+      console.warn(`Unknown hole shape: ${hole.hole_shape}`);
+  }
+};
+
+// lib/element-handlers/addPcbCutout/addCirclePcbCutout.ts
+import { ShapePath as ShapePath21 } from "lbrnts";
+var addCirclePcbCutout = (cutout, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskMargin,
+    soldermaskCutSetting
+  } = ctx;
+  const centerX = cutout.center.x + origin.x;
+  const centerY = cutout.center.y + origin.y;
+  if (cutout.radius > 0 && includeCopper) {
+    const circlePath = createCirclePath(centerX, centerY, cutout.radius);
+    project.children.push(
+      new ShapePath21({
+        cutIndex: throughBoardCutSetting.index,
+        verts: circlePath.verts,
+        prims: circlePath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (cutout.radius > 0 && includeSoldermask) {
+    const smRadius = cutout.radius + soldermaskMargin;
+    const outer = createCirclePath(centerX, centerY, smRadius);
+    project.children.push(
+      new ShapePath21({
+        cutIndex: soldermaskCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbCutout/addRectPcbCutout.ts
+import { ShapePath as ShapePath22 } from "lbrnts";
+var addRectPcbCutout = (cutout, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskMargin,
+    soldermaskCutSetting
+  } = ctx;
+  const centerX = cutout.center.x + origin.x;
+  const centerY = cutout.center.y + origin.y;
+  if (cutout.width > 0 && cutout.height > 0 && includeCopper) {
+    const rotation = (cutout.rotation ?? 0) * (Math.PI / 180);
+    const rectPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      cutout.width,
+      cutout.height,
+      0,
+      // no border radius for cutouts
+      4,
+      // segments
+      rotation
+    );
+    project.children.push(
+      new ShapePath22({
+        cutIndex: throughBoardCutSetting.index,
+        verts: rectPath.verts,
+        prims: rectPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (cutout.width > 0 && cutout.height > 0 && includeSoldermask) {
+    const rotation = (cutout.rotation ?? 0) * (Math.PI / 180);
+    const smWidth = cutout.width + 2 * soldermaskMargin;
+    const smHeight = cutout.height + 2 * soldermaskMargin;
+    const rectPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      smWidth,
+      smHeight,
+      0,
+      // no border radius for cutouts
+      4,
+      // segments
+      rotation
+    );
+    project.children.push(
+      new ShapePath22({
+        cutIndex: soldermaskCutSetting.index,
+        verts: rectPath.verts,
+        prims: rectPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbCutout/addPolygonPcbCutout.ts
+import { ShapePath as ShapePath23 } from "lbrnts";
+var addPolygonPcbCutout = (cutout, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskCutSetting,
+    soldermaskMargin
+  } = ctx;
+  if (cutout.points.length >= 3 && includeCopper) {
+    const polygonPath = createPolygonPathFromOutline(
+      cutout.points,
+      origin.x,
+      origin.y
+    );
+    project.children.push(
+      new ShapePath23({
+        cutIndex: throughBoardCutSetting.index,
+        verts: polygonPath.verts,
+        prims: polygonPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (cutout.points.length >= 3 && includeSoldermask) {
+    const points = soldermaskMargin && soldermaskMargin > 0 ? cutout.points.map((p) => ({
+      x: (p.x ?? 0) + (p.x ?? 0) > 0 ? soldermaskMargin : -soldermaskMargin,
+      y: (p.y ?? 0) + (p.y ?? 0) > 0 ? soldermaskMargin : -soldermaskMargin
+    })) : cutout.points;
+    const polygonPath = createPolygonPathFromOutline(points, origin.x, origin.y);
+    project.children.push(
+      new ShapePath23({
+        cutIndex: soldermaskCutSetting.index,
+        verts: polygonPath.verts,
+        prims: polygonPath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbCutout/addPathPcbCutout.ts
+import { ShapePath as ShapePath24 } from "lbrnts";
+var addPathPcbCutout = (cutout, ctx) => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskMargin,
+    soldermaskCutSetting
+  } = ctx;
+  if (cutout.route.length >= 2 && includeCopper) {
+    const verts = [];
+    const prims = [];
+    for (const point6 of cutout.route) {
+      verts.push({
+        x: point6.x + origin.x,
+        y: point6.y + origin.y
+      });
+      prims.push({ type: 0 });
+    }
+    project.children.push(
+      new ShapePath24({
+        cutIndex: throughBoardCutSetting.index,
+        verts,
+        prims,
+        isClosed: false
+        // Paths are typically not closed
+      })
+    );
+  }
+  if (cutout.route.length >= 2 && includeSoldermask) {
+    const verts = [];
+    const prims = [];
+    for (const point6 of cutout.route) {
+      verts.push({
+        x: point6.x + origin.x,
+        y: point6.y + origin.y
+      });
+      prims.push({ type: 0 });
+    }
+    project.children.push(
+      new ShapePath24({
+        cutIndex: soldermaskCutSetting.index,
+        verts,
+        prims,
+        isClosed: false
+        // Match the same path as the copper cutout
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPcbCutout/index.ts
+var addPcbCutout = (cutout, ctx) => {
+  switch (cutout.shape) {
+    case "circle":
+      return addCirclePcbCutout(cutout, ctx);
+    case "rect":
+      return addRectPcbCutout(cutout, ctx);
+    case "polygon":
+      return addPolygonPcbCutout(cutout, ctx);
+    case "path":
+      return addPathPcbCutout(cutout, ctx);
+    default:
+      const _exhaustive = cutout;
+      console.warn(`Unknown cutout shape: ${cutout.shape}`);
+  }
+};
+
 // lib/index.ts
 var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   const db = cju2(circuitJson);
@@ -1510,6 +1980,12 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   for (const via of db.pcb_via.list()) {
     addPcbVia(via, ctx);
   }
+  for (const hole of db.pcb_hole.list()) {
+    addPcbHole(hole, ctx);
+  }
+  for (const cutout of db.pcb_cutout.list()) {
+    addPcbCutout(cutout, ctx);
+  }
   if (ctx.includeCopper) {
     for (const net of Object.keys(connMap.netMap)) {
       const netGeoms = ctx.netGeoms.get(net);
@@ -1530,7 +2006,7 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
       for (const island of union.splitToIslands()) {
         const { verts, prims } = polygonToShapePathData(island);
         project.children.push(
-          new ShapePath16({
+          new ShapePath25({
             cutIndex: copperCutSetting.index,
             verts,
             prims,

package/lib/element-handlers/addPcbCutout/addCirclePcbCutout.ts

@@ -0,0 +1,52 @@
+import type { PcbCutoutCircle } from "circuit-json"
+import type { ConvertContext } from "../../ConvertContext"
+import { ShapePath } from "lbrnts"
+import { createCirclePath } from "../../helpers/circleShape"
+
+/**
+ * Adds a circular PCB cutout to the project
+ * Cutouts are regions removed from the board entirely
+ */
+export const addCirclePcbCutout = (
+  cutout: PcbCutoutCircle,
+  ctx: ConvertContext,
+): void => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskMargin,
+    soldermaskCutSetting,
+  } = ctx
+  const centerX = cutout.center.x + origin.x
+  const centerY = cutout.center.y + origin.y
+
+  // Add the cutout - cut through the board
+  if (cutout.radius > 0 && includeCopper) {
+    const circlePath = createCirclePath(centerX, centerY, cutout.radius)
+    project.children.push(
+      new ShapePath({
+        cutIndex: throughBoardCutSetting.index,
+        verts: circlePath.verts,
+        prims: circlePath.prims,
+        isClosed: true,
+      }),
+    )
+  }
+
+  // Add soldermask opening if drawing soldermask
+  if (cutout.radius > 0 && includeSoldermask) {
+    const smRadius = cutout.radius + soldermaskMargin
+    const outer = createCirclePath(centerX, centerY, smRadius)
+    project.children.push(
+      new ShapePath({
+        cutIndex: soldermaskCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true,
+      }),
+    )
+  }
+}

package/lib/element-handlers/addPcbCutout/addPathPcbCutout.ts

@@ -0,0 +1,73 @@
+import type { PcbCutoutPath } from "circuit-json"
+import type { ConvertContext } from "../../ConvertContext"
+import { ShapePath } from "lbrnts"
+
+/**
+ * Adds a path-based PCB cutout to the project
+ * Path cutouts create slots along a route (e.g., for routed slots or complex cutout paths)
+ */
+export const addPathPcbCutout = (
+  cutout: PcbCutoutPath,
+  ctx: ConvertContext,
+): void => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskMargin,
+    soldermaskCutSetting,
+  } = ctx
+
+  // For path cutouts, we need to create a stroke along the route with the given width
+  // For simplicity, we'll convert the path to a polyline
+  if (cutout.route.length >= 2 && includeCopper) {
+    const verts: { x: number; y: number }[] = []
+    const prims: { type: number }[] = []
+
+    for (const point of cutout.route) {
+      verts.push({
+        x: point.x + origin.x,
+        y: point.y + origin.y,
+      })
+      prims.push({ type: 0 })
+    }
+
+    // Note: slot_width, slot_length, space_between_slots, and slot_corner_radius
+    // would require more complex path offsetting and aren't currently implemented
+    // For now, we just create a simple path along the route
+    project.children.push(
+      new ShapePath({
+        cutIndex: throughBoardCutSetting.index,
+        verts,
+        prims,
+        isClosed: false, // Paths are typically not closed
+      }),
+    )
+  }
+
+  // Add soldermask opening if drawing soldermask
+  if (cutout.route.length >= 2 && includeSoldermask) {
+    const verts: { x: number; y: number }[] = []
+    const prims: { type: number }[] = []
+
+    // Create path with soldermask margin
+    for (const point of cutout.route) {
+      verts.push({
+        x: point.x + origin.x,
+        y: point.y + origin.y,
+      })
+      prims.push({ type: 0 })
+    }
+
+    project.children.push(
+      new ShapePath({
+        cutIndex: soldermaskCutSetting.index,
+        verts,
+        prims,
+        isClosed: false, // Match the same path as the copper cutout
+      }),
+    )
+  }
+}

package/lib/element-handlers/addPcbCutout/addPolygonPcbCutout.ts

@@ -0,0 +1,68 @@
+import type { PcbCutoutPolygon } from "circuit-json"
+import type { ConvertContext } from "../../ConvertContext"
+import { ShapePath } from "lbrnts"
+import { createPolygonPathFromOutline } from "../../helpers/polygonShape"
+
+/**
+ * Adds a polygon PCB cutout to the project
+ * Cutouts are regions removed from the board entirely
+ */
+export const addPolygonPcbCutout = (
+  cutout: PcbCutoutPolygon,
+  ctx: ConvertContext,
+): void => {
+  const {
+    project,
+    throughBoardCutSetting,
+    origin,
+    includeCopper,
+    includeSoldermask,
+    soldermaskCutSetting,
+    soldermaskMargin,
+  } = ctx
+
+  // Add the cutout - cut through the board
+  if (cutout.points.length >= 3 && includeCopper) {
+    const polygonPath = createPolygonPathFromOutline(
+      cutout.points,
+      origin.x,
+      origin.y,
+    )
+    project.children.push(
+      new ShapePath({
+        cutIndex: throughBoardCutSetting.index,
+        verts: polygonPath.verts,
+        prims: polygonPath.prims,
+        isClosed: true,
+      }),
+    )
+  }
+
+  // Add soldermask opening if drawing soldermask
+  if (cutout.points.length >= 3 && includeSoldermask) {
+    // Apply soldermask margin to the points if margin is specified
+    const points =
+      soldermaskMargin && soldermaskMargin > 0
+        ? cutout.points.map((p) => ({
+            x:
+              (p.x ?? 0) + (p.x ?? 0) > 0
+                ? soldermaskMargin
+                : -soldermaskMargin,
+            y:
+              (p.y ?? 0) + (p.y ?? 0) > 0
+                ? soldermaskMargin
+                : -soldermaskMargin,
+          }))
+        : cutout.points
+
+    const polygonPath = createPolygonPathFromOutline(points, origin.x, origin.y)
+    project.children.push(
+      new ShapePath({
+        cutIndex: soldermaskCutSetting.index,
+        verts: polygonPath.verts,
+        prims: polygonPath.prims,
+        isClosed: true,
+      }),
+    )
+  }
+}