@tscircuit/cli 0.1.2448 → 0.1.2449

package/dist/cli/main.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/cli/main.js
-size: 47851148 bytes
-sha256: b95bc5fe0094448e24fbf9fca20564b150e46b32beb45403576a1866a55f7e23
+size: 47854982 bytes
+sha256: ccd1dcb8f8fc2c5af463b1d040420c4e51b8451283b318de656885f02bdf9d13

package/dist/lib/index.js

@@ -74583,7 +74583,7 @@ import { applyToPoint as applyToPoint28 } from "transformation-matrix";
 import { ViaTenting } from "kicadts";
 import { Footprint as Footprint5 } from "kicadts";
 import { applyToPoint as applyToPoint29 } from "transformation-matrix";
-import { GrLine } from "kicadts";
+import { GrCircle, GrLine } from "kicadts";
 import {
   At as At3,
   GrText,
@@ -80735,7 +80735,34 @@ function createGrTextFromCircuitJson({
   grText.position = position;
   return grText;
 }
+var signedDistanceToPolygon = (x, y, geometry) => {
+  let inside = false;
+  let minDistanceSquared = Infinity;
+  for (const polygon of geometry) {
+    for (const ring of polygon) {
+      for (let i = 0;i < ring.length; i++) {
+        const [ax, ay] = ring[i];
+        const [bx, by] = ring[(i + 1) % ring.length];
+        const dx = bx - ax;
+        const dy = by - ay;
+        const lengthSquared = dx * dx + dy * dy;
+        if (lengthSquared === 0)
+          continue;
+        const px = x - ax;
+        const py = y - ay;
+        const t = Math.max(0, Math.min(1, (px * dx + py * dy) / lengthSquared));
+        const distanceSquared = (px - t * dx) ** 2 + (py - t * dy) ** 2;
+        minDistanceSquared = Math.min(minDistanceSquared, distanceSquared);
+        if (ay > y !== by > y && px < py * dx / dy)
+          inside = !inside;
+      }
+    }
+  }
+  const distance = Math.sqrt(minDistanceSquared);
+  return inside ? distance : -distance;
+};
 var KICAD_PCB_UNITS_PER_MM = 1e6;
+var KICAD_PCB_GRID_MM = 1 / KICAD_PCB_UNITS_PER_MM;
 var roundBoardCoordinate = (coordinateMm) => Math.round(coordinateMm * KICAD_PCB_UNITS_PER_MM) / KICAD_PCB_UNITS_PER_MM;
 var roundPolygonToKicadPrecision = (geometry) => geometry.map((polygon) => polygon.map((ring) => ring.map(([x, y]) => [roundBoardCoordinate(x), roundBoardCoordinate(y)])));
 var pointsAreEqual = (a, b) => !!a && !!b && a.x === b.x && a.y === b.y;
@@ -80765,6 +80792,11 @@ var appendGraphicLine = (kicadPcb, grLine) => {
   graphicLines.push(grLine);
   kicadPcb.graphicLines = graphicLines;
 };
+var appendGraphicCircle = (kicadPcb, grCircle) => {
+  const graphicCircles = kicadPcb.graphicCircles;
+  graphicCircles.push(grCircle);
+  kicadPcb.graphicCircles = graphicCircles;
+};
 var rotatePointAroundOrigin = (point, rotationDegrees = 0) => {
   if (!rotationDegrees)
     return point;
@@ -80875,6 +80907,7 @@ var AddGraphicsStage = class extends ConverterStage {
     if (firstOutline) {
       const pcbCutouts2 = this.ctx.db.pcb_cutout?.list() || [];
       const cutoutPolys = [];
+      const circularCutouts = /* @__PURE__ */ new Map;
       for (const cutout of pcbCutouts2) {
         if (cutout.shape === "rect") {
           const cutoutCorners = getRectCutoutCorners(cutout);
@@ -80882,11 +80915,29 @@ var AddGraphicsStage = class extends ConverterStage {
             [cutoutCorners.map((point) => toKicadPoint(point, c2kMatPcb))]
           ]);
         } else if (cutout.shape === "circle") {
-          cutoutPolys.push([
+          const geometry = [
             [
               circleToPolygon(cutout.center, cutout.radius).map(([x, y]) => toKicadPoint({ x, y }, c2kMatPcb))
             ]
-          ]);
+          ];
+          cutoutPolys.push(geometry);
+          const [cx, cy] = toKicadPoint(cutout.center, c2kMatPcb);
+          const [ex, ey] = toKicadPoint({ x: cutout.center.x + cutout.radius, y: cutout.center.y }, c2kMatPcb);
+          const radius = Math.hypot(ex - cx, ey - cy);
+          if (radius === 0)
+            continue;
+          circularCutouts.set(geometry, {
+            cx,
+            cy,
+            radius,
+            graphic: new GrCircle({
+              center: { x: cx, y: cy },
+              end: { x: ex, y: ey },
+              layer: "Edge.Cuts",
+              width: edgeCutsWidth,
+              fill: "none"
+            })
+          });
         } else if (cutout.shape === "polygon") {
           cutoutPolys.push([
             [cutout.points.map((point) => toKicadPoint(point, c2kMatPcb))]
@@ -80894,8 +80945,54 @@ var AddGraphicsStage = class extends ConverterStage {
         }
       }
       let boardGeom = otherOutlines.length > 0 ? import_polygon_clipping.default.union(firstOutline, ...otherOutlines) : firstOutline;
-      if (cutoutPolys.length > 0) {
-        boardGeom = import_polygon_clipping.default.difference(roundPolygonToKicadPrecision(boardGeom), ...cutoutPolys);
+      const bounds = cutoutPolys.map((geometry) => {
+        const circle = circularCutouts.get(geometry);
+        if (circle) {
+          const r = circle.radius + KICAD_PCB_GRID_MM;
+          return {
+            minX: circle.cx - r,
+            maxX: circle.cx + r,
+            minY: circle.cy - r,
+            maxY: circle.cy + r
+          };
+        }
+        const ring = geometry[0][0];
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const [x, y] of ring) {
+          minX = Math.min(minX, x);
+          maxX = Math.max(maxX, x);
+          minY = Math.min(minY, y);
+          maxY = Math.max(maxY, y);
+        }
+        return { minX, maxX, minY, maxY };
+      });
+      const clippedCutouts = cutoutPolys.filter((geometry, index) => {
+        const circle = circularCutouts.get(geometry);
+        if (!circle)
+          return true;
+        const requiredClearance = circle.radius + KICAD_PCB_GRID_MM;
+        if (signedDistanceToPolygon(circle.cx, circle.cy, boardGeom) <= requiredClearance)
+          return true;
+        const box = bounds[index];
+        const intersectsAnotherCutout = cutoutPolys.some((other, otherIndex) => {
+          if (index === otherIndex)
+            return false;
+          const otherBox = bounds[otherIndex];
+          if (box.minX > otherBox.maxX || box.maxX < otherBox.minX || box.minY > otherBox.maxY || box.maxY < otherBox.minY)
+            return false;
+          const otherCircle = circularCutouts.get(other);
+          if (otherCircle) {
+            return Math.hypot(circle.cx - otherCircle.cx, circle.cy - otherCircle.cy) <= requiredClearance + otherCircle.radius;
+          }
+          return signedDistanceToPolygon(circle.cx, circle.cy, other) >= -requiredClearance;
+        });
+        if (intersectsAnotherCutout)
+          return true;
+        appendGraphicCircle(kicadPcb, circle.graphic);
+        return false;
+      });
+      if (clippedCutouts.length > 0) {
+        boardGeom = import_polygon_clipping.default.difference(roundPolygonToKicadPrecision(boardGeom), ...clippedCutouts);
       }
       boardGeom = roundPolygonToKicadPrecision(boardGeom);
       for (const poly of boardGeom) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2448",
+  "version": "0.1.2449",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/cli"
@@ -44,7 +44,7 @@
     "circuit-json-to-fdm-component-box": "^0.0.2",
     "circuit-json-to-footprinter": "^0.0.59",
     "circuit-json-to-gerber": "^0.0.122",
-    "circuit-json-to-kicad": "0.0.271",
+    "circuit-json-to-kicad": "0.0.272",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-step": "^0.0.63",
     "circuit-json-to-tscircuit": "^0.0.50",