circuit-json-to-lbrn 0.0.7 → 0.0.8

package/dist/index.js

@@ -1,10 +1,576 @@
 // lib/index.ts
-import { LightBurnProject, CutSetting, ShapePath as ShapePath4 } from "lbrnts";
+import { LightBurnProject, CutSetting, ShapePath as ShapePath10 } from "lbrnts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
 
 // lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
 import { ShapePath } from "lbrnts";
 
+// lib/helpers/circleShape.ts
+var createCirclePath = (centerX, centerY, radius, segments = 64) => {
+  const verts = [];
+  const prims = [];
+  for (let i = 0; i < segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const x = centerX + radius * Math.cos(angle);
+    const y = centerY + radius * Math.sin(angle);
+    verts.push({ x, y });
+    prims.push({ type: 0 });
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
+var addCirclePlatedHole = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  if (platedHole.outer_diameter > 0) {
+    const outerRadius = platedHole.outer_diameter / 2;
+    const outer = createCirclePath(centerX, centerY, outerRadius);
+    project.children.push(
+      new ShapePath({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_diameter > 0) {
+    const innerRadius = platedHole.hole_diameter / 2;
+    const inner = createCirclePath(centerX, centerY, innerRadius);
+    project.children.push(
+      new ShapePath({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts
+import { ShapePath as ShapePath2 } from "lbrnts";
+
+// lib/helpers/ovalShape.ts
+var createOvalPath = (centerX, centerY, width, height, rotation = 0, segments = 64) => {
+  const verts = [];
+  const prims = [];
+  const radiusX = width / 2;
+  const radiusY = height / 2;
+  const cosTheta = Math.cos(rotation);
+  const sinTheta = Math.sin(rotation);
+  for (let i = 0; i < segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const localX = radiusX * Math.cos(angle);
+    const localY = radiusY * Math.sin(angle);
+    const rotatedX = centerX + localX * cosTheta - localY * sinTheta;
+    const rotatedY = centerY + localX * sinTheta + localY * cosTheta;
+    verts.push({ x: rotatedX, y: rotatedY });
+    prims.push({ type: 0 });
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts
+var addOvalPlatedHole = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  if (platedHole.outer_width <= 0 || platedHole.outer_height <= 0) {
+    return;
+  }
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const rotation = (platedHole.ccw_rotation ?? 0) * (Math.PI / 180);
+  if (platedHole.outer_width > 0 && platedHole.outer_height > 0) {
+    const outer = createOvalPath(
+      centerX,
+      centerY,
+      platedHole.outer_width,
+      platedHole.outer_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath2({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_width > 0 && platedHole.hole_height > 0) {
+    const inner = createOvalPath(
+      centerX,
+      centerY,
+      platedHole.hole_width,
+      platedHole.hole_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath2({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts
+import { ShapePath as ShapePath3 } from "lbrnts";
+
+// lib/helpers/roundedRectShape.ts
+var createRoundedRectPath = (centerX, centerY, width, height, borderRadius = 0, segments = 4, rotation = 0) => {
+  const verts = [];
+  const prims = [];
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const rotatePoint = (x, y) => {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return {
+      x: x * cos - y * sin,
+      y: x * sin + y * cos
+    };
+  };
+  const addPoint = (x, y) => {
+    const rotated = rotation ? rotatePoint(x, y) : { x, y };
+    verts.push({ x: centerX + rotated.x, y: centerY + rotated.y });
+    prims.push({ type: 0 });
+  };
+  addPoint(-halfWidth + borderRadius, -halfHeight);
+  addPoint(halfWidth - borderRadius, -halfHeight);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI * 1.5 + i * Math.PI * 0.5 / segments;
+      addPoint(
+        halfWidth - borderRadius + Math.cos(angle) * borderRadius,
+        -halfHeight + borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(halfWidth, -halfHeight);
+  }
+  addPoint(halfWidth, -halfHeight + borderRadius);
+  addPoint(halfWidth, halfHeight - borderRadius);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = i * Math.PI * 0.5 / segments;
+      addPoint(
+        halfWidth - borderRadius + Math.cos(angle) * borderRadius,
+        halfHeight - borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(halfWidth, halfHeight);
+  }
+  addPoint(halfWidth - borderRadius, halfHeight);
+  addPoint(-halfWidth + borderRadius, halfHeight);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI * 0.5 + i * Math.PI * 0.5 / segments;
+      addPoint(
+        -halfWidth + borderRadius + Math.cos(angle) * borderRadius,
+        halfHeight - borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(-halfWidth, halfHeight);
+  }
+  addPoint(-halfWidth, halfHeight - borderRadius);
+  addPoint(-halfWidth, -halfHeight + borderRadius);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI + i * Math.PI * 0.5 / segments;
+      addPoint(
+        -halfWidth + borderRadius + Math.cos(angle) * borderRadius,
+        -halfHeight + borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(-halfWidth, -halfHeight);
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts
+var addCircularHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const holeRadius = platedHole.hole_diameter / 2;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  const padPath = createRoundedRectPath(
+    centerX,
+    centerY,
+    padWidth,
+    padHeight,
+    borderRadius
+  );
+  project.children.push(
+    new ShapePath3({
+      cutIndex: copperCutSetting.index,
+      verts: padPath.verts,
+      prims: padPath.prims,
+      isClosed: true
+    })
+  );
+  if (holeRadius > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createCirclePath(holeCenterX, holeCenterY, holeRadius, 32);
+    project.children.push(
+      new ShapePath3({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts
+import { ShapePath as ShapePath4 } from "lbrnts";
+
+// lib/helpers/pathPointUtils.ts
+var createPointAdder = (verts, prims, options = {}) => {
+  const { rotation = 0, rotationCenter, translation } = options;
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const effectiveCenter = rotationCenter ?? translation ?? { x: 0, y: 0 };
+  return (x, y) => {
+    let px = x;
+    let py = y;
+    if (rotation) {
+      const cx = effectiveCenter.x;
+      const cy = effectiveCenter.y;
+      const dx = px - cx;
+      const dy = py - cy;
+      px = cx + dx * cos - dy * sin;
+      py = cy + dx * sin + dy * cos;
+    }
+    const tx = translation?.x ?? 0;
+    const ty = translation?.y ?? 0;
+    verts.push({ x: px + tx, y: py + ty });
+    prims.push({ type: 0 });
+  };
+};
+
+// lib/helpers/pillShape.ts
+var createPillPath = (centerX, centerY, width, height, rotation = 0, segments = 32) => {
+  const verts = [];
+  const prims = [];
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const radius = Math.min(halfWidth, halfHeight);
+  const isVertical = height > width;
+  const addPoint = createPointAdder(verts, prims, {
+    rotation,
+    rotationCenter: { x: centerX, y: centerY }
+  });
+  if (isVertical) {
+    const capOffset = halfHeight - radius;
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI + i / segments * Math.PI;
+      const x = centerX + radius * Math.cos(angle);
+      const y = centerY - capOffset + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX + radius, centerY + capOffset);
+    for (let i = 0; i <= segments; i++) {
+      const angle = i / segments * Math.PI;
+      const x = centerX + radius * Math.cos(angle);
+      const y = centerY + capOffset + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX - radius, centerY - capOffset);
+  } else {
+    const capOffset = halfWidth - radius;
+    for (let i = 0; i <= segments; i++) {
+      const angle = -Math.PI / 2 + i / segments * Math.PI;
+      const x = centerX + capOffset + radius * Math.cos(angle);
+      const y = centerY + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX - capOffset, centerY + radius);
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI / 2 + i / segments * Math.PI;
+      const x = centerX - capOffset + radius * Math.cos(angle);
+      const y = centerY + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX + capOffset, centerY - radius);
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts
+var addPillHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  if (padWidth > 0 && padHeight > 0) {
+    const padPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      padWidth,
+      padHeight,
+      borderRadius
+    );
+    project.children.push(
+      new ShapePath4({
+        cutIndex: copperCutSetting.index,
+        verts: padPath.verts,
+        prims: padPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  const holeWidth = platedHole.hole_width;
+  const holeHeight = platedHole.hole_height;
+  if (holeWidth > 0 && holeHeight > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createPillPath(
+      holeCenterX,
+      holeCenterY,
+      holeWidth,
+      holeHeight
+    );
+    project.children.push(
+      new ShapePath4({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addRotatedPillHoleWithRectPad.ts
+import { ShapePath as ShapePath5 } from "lbrnts";
+var addRotatedPillHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  const padRotation = (platedHole.rect_ccw_rotation ?? 0) * (Math.PI / 180);
+  if (padWidth > 0 && padHeight > 0) {
+    const padPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      padWidth,
+      padHeight,
+      borderRadius,
+      4,
+      padRotation
+    );
+    project.children.push(
+      new ShapePath5({
+        cutIndex: copperCutSetting.index,
+        verts: padPath.verts,
+        prims: padPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  const holeWidth = platedHole.hole_width;
+  const holeHeight = platedHole.hole_height;
+  const holeRotation = (platedHole.hole_ccw_rotation ?? 0) * (Math.PI / 180);
+  if (holeWidth > 0 && holeHeight > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createPillPath(
+      holeCenterX,
+      holeCenterY,
+      holeWidth,
+      holeHeight,
+      holeRotation
+    );
+    project.children.push(
+      new ShapePath5({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts
+import { ShapePath as ShapePath6 } from "lbrnts";
+
+// lib/helpers/polygonShape.ts
+var createPolygonPathFromOutline = (outline, offsetX, offsetY) => {
+  const verts = [];
+  for (const point2 of outline) {
+    const x = (point2.x ?? 0) + offsetX;
+    const y = (point2.y ?? 0) + offsetY;
+    verts.push({ x, y });
+  }
+  if (verts.length === 0) {
+    return { verts, prims: [] };
+  }
+  const first = verts[0];
+  verts.push({ x: first.x, y: first.y });
+  const prims = new Array(verts.length).fill({ type: 0 });
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts
+var addHoleWithPolygonPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  if (platedHole.pad_outline.length >= 3) {
+    const pad = createPolygonPathFromOutline(
+      platedHole.pad_outline,
+      platedHole.x + origin.x,
+      platedHole.y + origin.y
+    );
+    project.children.push(
+      new ShapePath6({
+        cutIndex: copperCutSetting.index,
+        verts: pad.verts,
+        prims: pad.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_shape === "circle" && platedHole.hole_diameter) {
+    const centerX = platedHole.x + platedHole.hole_offset_x + origin.x;
+    const centerY = platedHole.y + platedHole.hole_offset_y + origin.y;
+    const radius = platedHole.hole_diameter / 2;
+    const hole = createCirclePath(centerX, centerY, radius, 64);
+    project.children.push(
+      new ShapePath6({
+        cutIndex: throughBoardCutSetting.index,
+        verts: hole.verts,
+        prims: hole.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_shape === "pill" && platedHole.hole_diameter) {
+    const centerX = platedHole.x + platedHole.hole_offset_x + origin.x;
+    const centerY = platedHole.y + platedHole.hole_offset_y + origin.y;
+    const radius = platedHole.hole_diameter / 2;
+    const hole = createCirclePath(centerX, centerY, radius, 64);
+    project.children.push(
+      new ShapePath6({
+        cutIndex: throughBoardCutSetting.index,
+        verts: hole.verts,
+        prims: hole.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addPillPlatedHole.ts
+import { ShapePath as ShapePath7 } from "lbrnts";
+var addPcbPlatedHolePill = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const rotation = (platedHole.ccw_rotation || 0) * (Math.PI / 180);
+  if (platedHole.outer_width > 0 && platedHole.outer_height > 0) {
+    const outer = createPillPath(
+      centerX,
+      centerY,
+      platedHole.outer_width,
+      platedHole.outer_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath7({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_width > 0 && platedHole.hole_height > 0) {
+    const inner = createPillPath(
+      centerX,
+      centerY,
+      platedHole.hole_width,
+      platedHole.hole_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath7({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/index.ts
+var addPlatedHole = (platedHole, ctx) => {
+  switch (platedHole.shape) {
+    case "circle":
+      return addCirclePlatedHole(platedHole, ctx);
+    case "oval":
+      return addOvalPlatedHole(platedHole, ctx);
+    case "pill":
+      return addPcbPlatedHolePill(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 { Box } from "@flatten-js/core";
 import "lbrnts";
@@ -119,7 +685,7 @@ var addPcbTrace = (trace, ctx) => {
 
 // lib/element-handlers/addPcbBoard/index.ts
 import { Polygon, point } from "@flatten-js/core";
-import { ShapePath as ShapePath3 } from "lbrnts";
+import { ShapePath as ShapePath9 } from "lbrnts";
 
 // lib/polygon-to-shape-path.ts
 function polygonToShapePathData(polygon) {
@@ -175,7 +741,7 @@ var addPcbBoard = (board, ctx) => {
   if (!polygon) return;
   const { verts, prims } = polygonToShapePathData(polygon);
   project.children.push(
-    new ShapePath3({
+    new ShapePath9({
       cutIndex: throughBoardCutSetting.index,
       verts,
       prims,
@@ -286,6 +852,9 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   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);
   }
@@ -311,7 +880,7 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     for (const island of union.splitToIslands()) {
       const { verts, prims } = polygonToShapePathData(island);
       project.children.push(
-        new ShapePath4({
+        new ShapePath10({
           cutIndex: copperCutSetting.index,
           verts,
           prims,