@tscircuit/3d-viewer 0.0.490 → 0.0.492

package/dist/index.js

@@ -12269,7 +12269,7 @@ var require_expand = __commonJS({
     var expandGeom2 = require_expandGeom2();
     var expandGeom3 = require_expandGeom3();
     var expandPath2 = require_expandPath2();
-    var expand3 = (options, ...objects) => {
+    var expand2 = (options, ...objects) => {
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
       const results = objects.map((object) => {
@@ -12280,7 +12280,7 @@ var require_expand = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = expand3;
+    module.exports = expand2;
   }
 });
 
@@ -12478,7 +12478,7 @@ var require_extrudeRectangularPath2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/extrusions/extrudeRectangularPath2.js"(exports, module) {
     "use strict";
     var path2 = require_path2();
-    var expand3 = require_expand();
+    var expand2 = require_expand();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeRectangularPath2 = (options, geometry) => {
       const defaults = {
@@ -12490,7 +12490,7 @@ var require_extrudeRectangularPath2 = __commonJS({
       options.offset = [0, 0, height10];
       const points = path2.toPoints(geometry);
       if (points.length === 0) throw new Error("the given geometry cannot be empty");
-      const newgeometry = expand3(options, geometry);
+      const newgeometry = expand2(options, geometry);
       return extrudeLinearGeom2(options, newgeometry);
     };
     module.exports = extrudeRectangularPath2;
@@ -12504,7 +12504,7 @@ var require_extrudeRectangularGeom2 = __commonJS({
     var { area } = require_utils();
     var geom2 = require_geom2();
     var path2 = require_path2();
-    var expand3 = require_expand();
+    var expand2 = require_expand();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeRectangularGeom2 = (options, geometry) => {
       const defaults = {
@@ -12518,7 +12518,7 @@ var require_extrudeRectangularGeom2 = __commonJS({
       if (outlines.length === 0) throw new Error("the given geometry cannot be empty");
       const newparts = outlines.map((outline) => {
         if (area(outline) < 0) outline.reverse();
-        return expand3(options, path2.fromPoints({ closed: true }, outline));
+        return expand2(options, path2.fromPoints({ closed: true }, outline));
       });
       const allsides = newparts.reduce((sides2, part) => sides2.concat(geom2.toSides(part)), []);
       const newgeometry = geom2.create(allsides);
@@ -30825,7 +30825,7 @@ import * as THREE16 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.489",
+  version: "0.0.491",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -32504,6 +32504,11 @@ var platedHole = (plated_hole, ctx, options = {}) => {
     return (0, import_colors2.colorize)(colors.copper, (0, import_booleans2.subtract)(copperSolid, drill));
   }
   if (plated_hole.shape === "pill_hole_with_rect_pad") {
+    if (plated_hole.hole_shape !== "pill" || plated_hole.pad_shape !== "rect") {
+      throw new Error(
+        `Invalid hole_shape or pad_shape for pill_hole_with_rect_pad`
+      );
+    }
     const holeOffsetX = plated_hole.hole_offset_x || 0;
     const holeOffsetY = plated_hole.hole_offset_y || 0;
     const shouldRotate = plated_hole.hole_height > plated_hole.hole_width;
@@ -32705,7 +32710,6 @@ var platedHole = (plated_hole, ctx, options = {}) => {
 
 // src/BoardGeomBuilder.ts
 var import_extrusions4 = __toESM(require_extrusions(), 1);
-var import_expansions2 = __toESM(require_expansions(), 1);
 
 // src/geoms/brep-converter.ts
 var import_primitives5 = __toESM(require_primitives(), 1);
@@ -33180,6 +33184,9 @@ var BoardGeomBuilder = class {
     if (ph.shape === "circle" || ph.shape === "circular_hole_with_rect_pad") {
       let cyGeom = null;
       if (ph.shape === "circular_hole_with_rect_pad") {
+        if (ph.hole_shape !== "circle" || ph.pad_shape !== "rect") {
+          return;
+        }
         cyGeom = (0, import_primitives7.cylinder)({
           center: [
             ph.x + (ph.hole_offset_x || 0),
@@ -33251,6 +33258,9 @@ var BoardGeomBuilder = class {
       });
       this.platedHoleGeoms.push(platedHoleGeom);
     } else if (ph.shape === "pill_hole_with_rect_pad") {
+      if (ph.hole_shape !== "pill" || ph.pad_shape !== "rect") {
+        return;
+      }
       const shouldRotate = ph.hole_height > ph.hole_width;
       const holeWidth = shouldRotate ? ph.hole_height : ph.hole_width;
       const holeHeight = shouldRotate ? ph.hole_width : ph.hole_height;
@@ -33353,95 +33363,68 @@ var BoardGeomBuilder = class {
       this.platedHoleGeoms = this.platedHoleGeoms.map(
         (phg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(phg, copperCut))
       );
-    } else if (hole.hole_shape === "pill" || hole.hole_shape === "rotated_pill") {
-      const holeWidth = hole.hole_width;
-      const holeHeight = hole.hole_height;
-      const holeRadius = Math.min(holeWidth, holeHeight) / 2;
-      const rectLength = Math.abs(holeWidth - holeHeight);
-      const isRotated = hole.hole_shape === "rotated_pill";
-      let pillHole;
-      if (holeWidth > holeHeight) {
-        pillHole = (0, import_booleans5.union)(
-          (0, import_primitives7.cuboid)({
-            center: [hole.x, hole.y, 0],
-            size: [rectLength, holeHeight, holeDepth]
-          }),
-          (0, import_primitives7.cylinder)({
-            center: [hole.x - rectLength / 2, hole.y, 0],
-            radius: holeRadius,
-            height: holeDepth
-          }),
-          (0, import_primitives7.cylinder)({
-            center: [hole.x + rectLength / 2, hole.y, 0],
-            radius: holeRadius,
-            height: holeDepth
-          })
+    } else if (hole.hole_shape === "pill" || hole.hole_shape === "rotated_pill" || hole.hole_shape === "oval") {
+      const holeWidth = hole.hole_width ?? hole.hole_diameter;
+      const holeHeight = hole.hole_height ?? hole.hole_diameter;
+      const rotation2 = hole.ccw_rotation ?? hole.rotation ?? 0;
+      const copperInset2 = 0.02;
+      const createHoleGeom = (w, h2, depth, isOval) => {
+        if (w <= 0 || h2 <= 0) return null;
+        if (isOval) {
+          return (0, import_transforms6.translate)(
+            [0, 0, -depth / 2],
+            (0, import_extrusions4.extrudeLinear)(
+              { height: depth },
+              (0, import_primitives7.ellipse)({ radius: [w / 2, h2 / 2] })
+            )
+          );
+        }
+        const radius = Math.min(w, h2) / 2;
+        const length2 = Math.abs(w - h2);
+        if (w > h2) {
+          return (0, import_booleans5.union)(
+            (0, import_primitives7.cuboid)({ center: [0, 0, 0], size: [length2, h2, depth] }),
+            (0, import_primitives7.cylinder)({ center: [-length2 / 2, 0, 0], radius, height: depth }),
+            (0, import_primitives7.cylinder)({ center: [length2 / 2, 0, 0], radius, height: depth })
+          );
+        }
+        return (0, import_booleans5.union)(
+          (0, import_primitives7.cuboid)({ center: [0, 0, 0], size: [w, length2, depth] }),
+          (0, import_primitives7.cylinder)({ center: [0, -length2 / 2, 0], radius, height: depth }),
+          (0, import_primitives7.cylinder)({ center: [0, length2 / 2, 0], radius, height: depth })
         );
-      } else {
-        pillHole = (0, import_booleans5.union)(
-          (0, import_primitives7.cuboid)({
-            center: [hole.x, hole.y, 0],
-            size: [holeWidth, rectLength, holeDepth]
-          }),
-          (0, import_primitives7.cylinder)({
-            center: [hole.x, hole.y - rectLength / 2, 0],
-            radius: holeRadius,
-            height: holeDepth
-          }),
-          (0, import_primitives7.cylinder)({
-            center: [hole.x, hole.y + rectLength / 2, 0],
-            radius: holeRadius,
-            height: holeDepth
-          })
+      };
+      let boardHole = createHoleGeom(
+        holeWidth,
+        holeHeight,
+        holeDepth,
+        hole.hole_shape === "oval"
+      );
+      let copperCut = createHoleGeom(
+        holeWidth - 2 * copperInset2,
+        holeHeight - 2 * copperInset2,
+        holeDepth,
+        hole.hole_shape === "oval"
+      );
+      if (boardHole && rotation2 !== 0) {
+        boardHole = (0, import_transforms6.rotateZ)(rotation2 * Math.PI / 180, boardHole);
+      }
+      if (copperCut && rotation2 !== 0) {
+        copperCut = (0, import_transforms6.rotateZ)(rotation2 * Math.PI / 180, copperCut);
+      }
+      if (boardHole) {
+        const positionedBoardHole = (0, import_transforms6.translate)([hole.x, hole.y, 0], boardHole);
+        this.boardGeom = (0, import_booleans5.subtract)(this.boardGeom, positionedBoardHole);
+        this.padGeoms = this.padGeoms.map(
+          (pg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(pg, positionedBoardHole))
         );
       }
-      if (isRotated) {
-        const rotationRadians = hole.ccw_rotation * Math.PI / 180;
-        pillHole = (0, import_transforms6.rotateZ)(rotationRadians, pillHole);
+      if (copperCut) {
+        const positionedCopperCut = (0, import_transforms6.translate)([hole.x, hole.y, 0], copperCut);
+        this.platedHoleGeoms = this.platedHoleGeoms.map(
+          (phg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(phg, positionedCopperCut))
+        );
       }
-      this.boardGeom = (0, import_booleans5.subtract)(this.boardGeom, pillHole);
-      this.padGeoms = this.padGeoms.map(
-        (pg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(pg, pillHole))
-      );
-      const copperPill = (0, import_expansions2.expand)({ delta: -copperInset }, pillHole);
-      this.platedHoleGeoms = this.platedHoleGeoms.map(
-        (phg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(phg, copperPill))
-      );
-    } else if (hole.hole_shape === "oval") {
-      const holeWidth = hole.hole_width;
-      const holeHeight = hole.hole_height;
-      const ellipseGeom = (0, import_transforms6.translate)(
-        [hole.x, hole.y, 0],
-        (0, import_transforms6.translate)(
-          [0, 0, -holeDepth / 2],
-          (0, import_extrusions4.extrudeLinear)(
-            { height: holeDepth },
-            (0, import_primitives7.ellipse)({ radius: [holeWidth / 2, holeHeight / 2] })
-          )
-        )
-      );
-      this.boardGeom = (0, import_booleans5.subtract)(this.boardGeom, ellipseGeom);
-      this.padGeoms = this.padGeoms.map(
-        (pg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(pg, ellipseGeom))
-      );
-      const copperEllipseGeom = (0, import_transforms6.translate)(
-        [hole.x, hole.y, 0],
-        (0, import_transforms6.translate)(
-          [0, 0, -holeDepth / 2],
-          (0, import_extrusions4.extrudeLinear)(
-            { height: holeDepth },
-            (0, import_primitives7.ellipse)({
-              radius: [
-                holeWidth / 2 - copperInset,
-                holeHeight / 2 - copperInset
-              ]
-            })
-          )
-        )
-      );
-      this.platedHoleGeoms = this.platedHoleGeoms.map(
-        (phg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(phg, copperEllipseGeom))
-      );
     }
   }
   processPad(pad2) {
@@ -36344,16 +36327,7 @@ function createPlatedHoleDrill({
 }
 
 // src/utils/manifold/process-non-plated-holes.ts
-function isCircleHole(hole) {
-  return hole.hole_shape === "circle" && typeof hole.hole_diameter === "number";
-}
-function isPillHole(hole) {
-  return hole.hole_shape === "pill" && typeof hole.hole_width === "number" && typeof hole.hole_height === "number";
-}
-function isRotatedPillHole(hole) {
-  return hole.hole_shape === "rotated_pill" && typeof hole.hole_width === "number" && typeof hole.hole_height === "number" && typeof hole.ccw_rotation === "number";
-}
-function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
+function processNonPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbThickness, manifoldInstancesForCleanup) {
   const nonPlatedHoleBoardDrills = [];
   const pcbHoles = su14(circuitJson).pcb_hole.list();
   const createPillOp = (width10, height10, depth) => {
@@ -36367,52 +36341,71 @@ function processNonPlatedHolesForManifold(Manifold, circuitJson, pcbThickness, m
     manifoldInstancesForCleanup.push(pillOp);
     return pillOp;
   };
+  const createEllipsePoints2 = (w, h2, segments) => {
+    const points = [];
+    for (let i = 0; i < segments; i++) {
+      const theta = 2 * Math.PI * i / segments;
+      points.push([w / 2 * Math.cos(theta), h2 / 2 * Math.sin(theta)]);
+    }
+    return points;
+  };
   pcbHoles.forEach((hole) => {
-    if (isCircleHole(hole)) {
-      const translatedDrill = createCircleHoleDrill({
+    const holeShape = hole.hole_shape;
+    const holeX = hole.x;
+    const holeY = hole.y;
+    const drillDepth = pcbThickness * 1.2;
+    const rotation2 = hole.ccw_rotation ?? hole.rotation ?? 0;
+    const holeW = hole.hole_width ?? hole.hole_diameter;
+    const holeH = hole.hole_height ?? hole.hole_diameter;
+    let holeOp = null;
+    if (holeShape === "circle") {
+      holeOp = createCircleHoleDrill({
         Manifold,
-        x: hole.x,
-        y: hole.y,
+        x: holeX,
+        y: holeY,
         diameter: hole.hole_diameter,
         thickness: pcbThickness,
         segments: SMOOTH_CIRCLE_SEGMENTS
       });
-      manifoldInstancesForCleanup.push(translatedDrill);
-      nonPlatedHoleBoardDrills.push(translatedDrill);
-    } else if (isPillHole(hole)) {
-      const holeW = hole.hole_width;
-      const holeH = hole.hole_height;
-      const drillDepth = pcbThickness * 1.2;
-      const pillDrillOp = createPillOp(holeW, holeH, drillDepth);
-      const translatedPillDrill = pillDrillOp.translate([hole.x, hole.y, 0]);
-      manifoldInstancesForCleanup.push(translatedPillDrill);
-      nonPlatedHoleBoardDrills.push(translatedPillDrill);
-    } else if (isRotatedPillHole(hole)) {
-      const holeW = hole.hole_width;
-      const holeH = hole.hole_height;
-      const drillDepth = pcbThickness * 1.2;
-      let pillDrillOp = createPillOp(holeW, holeH, drillDepth);
-      const rotatedOp = pillDrillOp.rotate([0, 0, hole.ccw_rotation]);
-      manifoldInstancesForCleanup.push(rotatedOp);
-      pillDrillOp = rotatedOp;
-      const translatedPillDrill = pillDrillOp.translate([hole.x, hole.y, 0]);
-      manifoldInstancesForCleanup.push(translatedPillDrill);
-      nonPlatedHoleBoardDrills.push(translatedPillDrill);
-    } else if (hole.hole_shape === "oval") {
-      const holeW = hole.hole_width;
-      const holeH = hole.hole_height;
-      const drillDepth = pcbThickness * 1.2;
-      const ovalDrillOp = Manifold.cylinder(
+      nonPlatedHoleBoardDrills.push(holeOp);
+      manifoldInstancesForCleanup.push(holeOp);
+      return;
+    }
+    if (holeShape === "pill" || holeShape === "rotated_pill") {
+      holeOp = createPillOp(holeW, holeH, drillDepth);
+    } else if (holeShape === "oval") {
+      let points = createEllipsePoints2(holeW, holeH, SMOOTH_CIRCLE_SEGMENTS);
+      let area = 0;
+      for (let i = 0; i < points.length; i++) {
+        const j = (i + 1) % points.length;
+        area += points[i][0] * points[j][1];
+        area -= points[j][0] * points[i][1];
+      }
+      if (area <= 0) {
+        points = points.reverse();
+      }
+      const crossSection = CrossSection.ofPolygons([points]);
+      manifoldInstancesForCleanup.push(crossSection);
+      holeOp = Manifold.extrude(
+        crossSection,
         drillDepth,
-        1,
-        1,
-        SMOOTH_CIRCLE_SEGMENTS,
+        0,
+        0,
+        [1, 1],
         true
-      ).scale([holeW / 2, holeH / 2, 1]);
-      manifoldInstancesForCleanup.push(ovalDrillOp);
-      const translatedOvalDrill = ovalDrillOp.translate([hole.x, hole.y, 0]);
-      manifoldInstancesForCleanup.push(translatedOvalDrill);
-      nonPlatedHoleBoardDrills.push(translatedOvalDrill);
+        // center
+      );
+      manifoldInstancesForCleanup.push(holeOp);
+    }
+    if (holeOp) {
+      if (rotation2 !== 0) {
+        const rotatedOp = holeOp.rotate([0, 0, rotation2]);
+        manifoldInstancesForCleanup.push(rotatedOp);
+        holeOp = rotatedOp;
+      }
+      const translatedHole = holeOp.translate([holeX, holeY, 0]);
+      manifoldInstancesForCleanup.push(translatedHole);
+      nonPlatedHoleBoardDrills.push(translatedHole);
     }
   });
   return { nonPlatedHoleBoardDrills };
@@ -36675,6 +36668,9 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         color: COPPER_COLOR
       });
     } else if (ph.shape === "pill_hole_with_rect_pad") {
+      if (ph.hole_shape !== "pill" || ph.pad_shape !== "rect") {
+        return;
+      }
       const holeW = ph.hole_width;
       const holeH = ph.hole_height;
       const holeOffsetX = ph.hole_offset_x || 0;
@@ -36686,9 +36682,11 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       const drillW = holeW + 2 * MANIFOLD_Z_OFFSET;
       const drillH = holeH + 2 * MANIFOLD_Z_OFFSET;
       const drillDepth = pcbThickness * 1.2;
-      let boardPillDrillOp = createPillOp(drillW, drillH, drillDepth).translate(
-        [holeOffsetX, holeOffsetY, 0]
-      );
+      const boardPillDrillOp = createPillOp(
+        drillW,
+        drillH,
+        drillDepth
+      ).translate([holeOffsetX, holeOffsetY, 0]);
       const translatedBoardPillDrill = boardPillDrillOp.translate([
         ph.x,
         ph.y,
@@ -36884,7 +36882,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       }
       const outerCrossSection = CrossSection.ofPolygons([outerPoints]);
       manifoldInstancesForCleanup.push(outerCrossSection);
-      let outerCopperOp = Manifold.extrude(
+      const outerCopperOp = Manifold.extrude(
         outerCrossSection,
         copperPartThickness,
         0,
@@ -36903,7 +36901,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       }
       const innerCrossSection = CrossSection.ofPolygons([innerPoints]);
       manifoldInstancesForCleanup.push(innerCrossSection);
-      let innerDrillOp = Manifold.extrude(
+      const innerDrillOp = Manifold.extrude(
         innerCrossSection,
         copperPartThickness * 1.05,
         0,
@@ -36938,6 +36936,9 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         color: COPPER_COLOR
       });
     } else if (ph.shape === "circular_hole_with_rect_pad") {
+      if (ph.hole_shape !== "circle" || ph.pad_shape !== "rect") {
+        return;
+      }
       const holeOffsetX = ph.hole_offset_x || 0;
       const holeOffsetY = ph.hole_offset_y || 0;
       const translatedDrill = createCircleHoleDrill({
@@ -37028,7 +37029,7 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
       });
     }
   });
-  let platedHoleSubtractOp = void 0;
+  let platedHoleSubtractOp;
   if (platedHoleCopperOpsForSubtract.length > 0) {
     platedHoleSubtractOp = Manifold.union(platedHoleCopperOpsForSubtract);
     manifoldInstancesForCleanup.push(platedHoleSubtractOp);
@@ -37712,6 +37713,7 @@ var useManifoldBoardBuilder = (manifoldJSModule, circuitJson) => {
       let holeUnion = null;
       const { nonPlatedHoleBoardDrills } = processNonPlatedHolesForManifold(
         Manifold,
+        CrossSection,
         circuitJson,
         currentPcbThickness,
         manifoldInstancesForCleanup.current

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.490",
+  "version": "0.0.492",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",