circuit-json-to-gerber 0.0.81 → 0.0.82

package/dist/{chunk-LJRHQISL.js → chunk-7LG6NVYJ.js}

@@ -1329,6 +1329,134 @@ var defineCommonMacros = (glayer) => {
   );
 };
 
+// src/gerber/convert-soup-to-gerber-commands/getSilkscreenShapeStroke.ts
+import {
+  applyToPoint,
+  compose,
+  identity,
+  rotate,
+  translate
+} from "transformation-matrix";
+var SILKSCREEN_SHAPE_TYPES = [
+  "pcb_silkscreen_line",
+  "pcb_silkscreen_rect",
+  "pcb_silkscreen_circle",
+  "pcb_silkscreen_oval",
+  "pcb_silkscreen_pill"
+];
+var isSilkscreenShape = (element) => SILKSCREEN_SHAPE_TYPES.includes(element.type);
+var DEFAULT_STROKE_WIDTH = 0.1;
+var ELLIPSE_SEGMENTS = 48;
+var CORNER_SEGMENTS = 12;
+var rotationAboutCenter = (center, ccwDegrees) => ccwDegrees ? compose(
+  translate(center.x, center.y),
+  rotate(ccwDegrees * Math.PI / 180),
+  translate(-center.x, -center.y)
+) : identity();
+var ellipseRoute = (center, radiusX, radiusY, ccwDegrees = 0) => {
+  const matrix = rotationAboutCenter(center, ccwDegrees);
+  return Array.from({ length: ELLIPSE_SEGMENTS + 1 }, (_, i) => {
+    const angle = i / ELLIPSE_SEGMENTS * Math.PI * 2;
+    return applyToPoint(matrix, {
+      x: center.x + radiusX * Math.cos(angle),
+      y: center.y + radiusY * Math.sin(angle)
+    });
+  });
+};
+var rectangleRoute = (center, width, height, cornerRadius, ccwDegrees = 0) => {
+  const halfW = width / 2;
+  const halfH = height / 2;
+  const route = [];
+  if (cornerRadius <= 0) {
+    route.push(
+      { x: center.x - halfW, y: center.y - halfH },
+      { x: center.x + halfW, y: center.y - halfH },
+      { x: center.x + halfW, y: center.y + halfH },
+      { x: center.x - halfW, y: center.y + halfH }
+    );
+  } else {
+    const insetW = halfW - cornerRadius;
+    const insetH = halfH - cornerRadius;
+    const corners = [
+      { x: center.x + insetW, y: center.y + insetH, start: 0 },
+      { x: center.x - insetW, y: center.y + insetH, start: Math.PI / 2 },
+      { x: center.x - insetW, y: center.y - insetH, start: Math.PI },
+      { x: center.x + insetW, y: center.y - insetH, start: 3 * Math.PI / 2 }
+    ];
+    for (const corner of corners) {
+      for (let i = 0; i <= CORNER_SEGMENTS; i++) {
+        const angle = corner.start + i / CORNER_SEGMENTS * (Math.PI / 2);
+        route.push({
+          x: corner.x + cornerRadius * Math.cos(angle),
+          y: corner.y + cornerRadius * Math.sin(angle)
+        });
+      }
+    }
+  }
+  route.push(route[0]);
+  const matrix = rotationAboutCenter(center, ccwDegrees);
+  return route.map((point) => applyToPoint(matrix, point));
+};
+var clampCornerRadius = (width, height, cornerRadius) => {
+  if (typeof cornerRadius !== "number" || cornerRadius <= 0) return 0;
+  return Math.min(cornerRadius, width / 2, height / 2);
+};
+var getSilkscreenShapeStroke = (element) => {
+  const strokeWidth = element.stroke_width ?? DEFAULT_STROKE_WIDTH;
+  switch (element.type) {
+    case "pcb_silkscreen_line":
+      return {
+        route: [
+          { x: element.x1, y: element.y1 },
+          { x: element.x2, y: element.y2 }
+        ],
+        strokeWidth
+      };
+    case "pcb_silkscreen_rect":
+      return {
+        route: rectangleRoute(
+          element.center,
+          element.width,
+          element.height,
+          clampCornerRadius(
+            element.width,
+            element.height,
+            element.corner_radius
+          ),
+          element.ccw_rotation ?? 0
+        ),
+        strokeWidth
+      };
+    case "pcb_silkscreen_circle":
+      return {
+        route: ellipseRoute(element.center, element.radius, element.radius),
+        strokeWidth
+      };
+    case "pcb_silkscreen_oval":
+      return {
+        route: ellipseRoute(
+          element.center,
+          element.radius_x,
+          element.radius_y,
+          element.ccw_rotation ?? 0
+        ),
+        strokeWidth
+      };
+    case "pcb_silkscreen_pill":
+      return {
+        route: rectangleRoute(
+          element.center,
+          element.width,
+          element.height,
+          Math.min(element.width, element.height) / 2
+        ),
+        strokeWidth
+      };
+    default:
+      return null;
+  }
+};
+
 // src/gerber/convert-soup-to-gerber-commands/defineAperturesForLayer.ts
 import stableStringify from "fast-json-stable-stringify";
 
@@ -1878,6 +2006,20 @@ function getAllApertureTemplateConfigsForLayer({
     } else if (elm.type === "pcb_silkscreen_path") {
       if (!isFabricationLayer)
         addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
+    } else if (isSilkscreenShape(elm)) {
+      if (!isFabricationLayer) {
+        addConfigIfNew({
+          standard_template_code: "C",
+          diameter: elm.stroke_width ?? 0.1
+        });
+        if (elm.is_filled === true) {
+          addConfigIfNew(REGION_APERTURE_CONFIG);
+        }
+      }
+    } else if (elm.type === "pcb_silkscreen_graphic") {
+      if (glayer_name.endsWith("_SilkScreen")) {
+        addConfigIfNew(REGION_APERTURE_CONFIG);
+      }
     } else if (elm.type === "pcb_silkscreen_text") {
       if (!isFabricationLayer)
         addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
@@ -1953,7 +2095,7 @@ var findApertureNumber = (glayer, search_params) => {
 // package.json
 var package_default = {
   name: "circuit-json-to-gerber",
-  version: "0.0.80",
+  version: "0.0.81",
   main: "dist/index.js",
   type: "module",
   scripts: {
@@ -2164,11 +2306,11 @@ var offsetPolygonOutline = (points, offset) => {
 // src/gerber/convert-soup-to-gerber-commands/index.ts
 import { lineAlphabet } from "@tscircuit/alphabet";
 import {
-  applyToPoint,
-  compose,
-  identity,
-  rotate,
-  translate
+  applyToPoint as applyToPoint2,
+  compose as compose2,
+  identity as identity2,
+  rotate as rotate2,
+  translate as translate2
 } from "transformation-matrix";
 
 // src/gerber/convert-soup-to-gerber-commands/fabricationLayerRefs.ts
@@ -2597,18 +2739,18 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
     const shouldMirror = element.is_mirrored !== void 0 ? element.is_mirrored : element.layer === "bottom";
     if (shouldMirror) {
       transforms.push(
-        translate(cx, cy),
+        translate2(cx, cy),
         { a: -1, b: 0, c: 0, d: 1, e: 0, f: 0 },
-        translate(-cx, -cy)
+        translate2(-cx, -cy)
       );
       rotation = -rotation;
     }
     if (rotation) {
       const rad = rotation * Math.PI / 180;
-      transforms.push(translate(cx, cy), rotate(rad), translate(-cx, -cy));
+      transforms.push(translate2(cx, cy), rotate2(rad), translate2(-cx, -cy));
     }
-    const transformMatrix = transforms.length > 0 ? compose(...transforms) : void 0;
-    const applyTransform = (point) => transformMatrix ? applyToPoint(transformMatrix, point) : point;
+    const transformMatrix = transforms.length > 0 ? compose2(...transforms) : void 0;
+    const applyTransform = (point) => transformMatrix ? applyToPoint2(transformMatrix, point) : point;
     if (element.is_knockout) {
       const padding = element.knockout_padding ?? {
         left: 0.2,
@@ -2797,17 +2939,17 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
             { x: -w, y: -h }
             // Bottom-left
           ];
-          let transformMatrix = identity();
+          let transformMatrix = identity2();
           if (rotation) {
             const angle_rad = rotation * Math.PI / 180;
-            transformMatrix = rotate(angle_rad);
+            transformMatrix = rotate2(angle_rad);
           }
-          transformMatrix = compose(
-            translate(center.x, center.y),
+          transformMatrix = compose2(
+            translate2(center.x, center.y),
             transformMatrix
           );
           const transformedPoints = points.map(
-            (p) => applyToPoint(transformMatrix, p)
+            (p) => applyToPoint2(transformMatrix, p)
           );
           const regionApertureNumber = getRegionApertureNumber(copper_glayer);
           const rect_builder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
@@ -2931,6 +3073,69 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
           glayer.push(...gerber.build());
         }
+      } else if (isSilkscreenShape(element) && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          const stroke = getSilkscreenShapeStroke(element);
+          if (stroke) {
+            const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+            const isFilled = element.is_filled === true;
+            const isStroked = element.has_stroke !== false;
+            if (isFilled) {
+              addClosedRegionFromPoints({
+                target: glayer,
+                apertureSource: glayer,
+                points: stroke.route
+              });
+            }
+            if (isStroked) {
+              renderOpenPath({
+                element: {
+                  type: element.type,
+                  stroke_width: stroke.strokeWidth,
+                  is_stroke_dashed: element.is_stroke_dashed
+                },
+                glayer,
+                apertureConfig: {
+                  standard_template_code: "C",
+                  diameter: stroke.strokeWidth
+                },
+                route: stroke.route,
+                mapY: mfy
+              });
+            }
+          }
+        }
+      } else if (
+        // pcb_silkscreen_graphic is newer than this repo's pinned circuit-json,
+        // so it isn't in the AnyCircuitElement union yet — match it structurally.
+        element.type === "pcb_silkscreen_graphic" && isOuterLayerRef(layer)
+      ) {
+        const graphic = element;
+        if (graphic.layer === layer && graphic.brep_shape) {
+          const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+          const { outer_ring, inner_rings } = graphic.brep_shape;
+          const regionApertureNumber = getRegionApertureNumber(glayer);
+          const outerBuilder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
+          drawRingToBuilder(outerBuilder, reverseRing(outer_ring));
+          outerBuilder.add("end_region_statement", {});
+          glayer.push(...outerBuilder.build());
+          if (inner_rings && inner_rings.length > 0) {
+            glayer.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build()
+            );
+            for (const inner_ring of inner_rings) {
+              const innerBuilder = gerberBuilder().add("select_aperture", {
+                aperture_number: regionApertureNumber
+              }).add("start_region_statement", {});
+              drawRingToBuilder(innerBuilder, inner_ring);
+              innerBuilder.add("end_region_statement", {});
+              glayer.push(...innerBuilder.build());
+            }
+            glayer.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "D" }).build()
+            );
+          }
+        }
       } else if (element.type === "pcb_silkscreen_text" && isOuterLayerRef(layer)) {
         renderVectorText(
           element,
@@ -3371,23 +3576,23 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
               Math.min(corner_radius ?? 0, Math.abs(w), Math.abs(h))
             );
             const makeTransformMatrix = () => {
-              let transformMatrix2 = identity();
+              let transformMatrix2 = identity2();
               if (rotation) {
                 const angle_rad = rotation * Math.PI / 180;
-                transformMatrix2 = rotate(angle_rad);
+                transformMatrix2 = rotate2(angle_rad);
               }
-              return compose(translate(center.x, center.y), transformMatrix2);
+              return compose2(translate2(center.x, center.y), transformMatrix2);
             };
             const transformMatrix = makeTransformMatrix();
             if (r > 0) {
               const startPoint = { x: -w + r, y: h };
-              let currentPoint = applyToPoint(transformMatrix, startPoint);
+              let currentPoint = applyToPoint2(transformMatrix, startPoint);
               cutout_builder.add("move_operation", {
                 x: currentPoint.x,
                 y: mfy(currentPoint.y)
               });
               const addLine = (point) => {
-                const transformedPoint = applyToPoint(transformMatrix, point);
+                const transformedPoint = applyToPoint2(transformMatrix, point);
                 cutout_builder.add("plot_operation", {
                   x: transformedPoint.x,
                   y: mfy(transformedPoint.y)
@@ -3395,11 +3600,11 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
                 currentPoint = transformedPoint;
               };
               const addArc = (options) => {
-                const transformedPoint = applyToPoint(
+                const transformedPoint = applyToPoint2(
                   transformMatrix,
                   options.point
                 );
-                const transformedCenter = applyToPoint(
+                const transformedCenter = applyToPoint2(
                   transformMatrix,
                   options.center
                 );
@@ -3443,7 +3648,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
                 // Bottom-left
               ];
               const transformedPoints = points.map(
-                (p) => applyToPoint(transformMatrix, p)
+                (p) => applyToPoint2(transformMatrix, p)
               );
               cutout_builder.add("move_operation", {
                 x: transformedPoints[0].x,
@@ -3521,4 +3726,4 @@ export {
   stringifyGerberCommands,
   convertSoupToGerberCommands
 };
-//# sourceMappingURL=chunk-LJRHQISL.js.map
+//# sourceMappingURL=chunk-7LG6NVYJ.js.map