circuit-json-to-gerber 0.0.46 → 0.0.48

package/dist/{chunk-WSRKOLQZ.js → chunk-VM5XFQ53.js}

@@ -1422,7 +1422,7 @@ var findApertureNumber = (glayer, search_params) => {
 // package.json
 var package_default = {
   name: "circuit-json-to-gerber",
-  version: "0.0.45",
+  version: "0.0.47",
   main: "dist/index.js",
   type: "module",
   scripts: {
@@ -1447,7 +1447,7 @@ var package_default = {
     "@types/react-dom": "^19.1.5",
     archiver: "^7.0.1",
     "bun-match-svg": "^0.0.13",
-    "circuit-json": "^0.0.317",
+    "circuit-json": "^0.0.378",
     commander: "^12.1.0",
     "gerber-to-svg": "^4.2.8",
     gerberts: "^0.0.3",
@@ -1542,6 +1542,7 @@ import {
 } from "transformation-matrix";
 var convertSoupToGerberCommands = (soup, opts = {}) => {
   opts.flip_y_axis ??= false;
+  const hasPanel = soup.some((e) => e.type === "pcb_panel");
   const glayers = {
     F_Cu: getCommandHeaders({
       layer: "top",
@@ -1771,6 +1772,179 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
       );
     }
   };
+  const drawRingToBuilder = (builder, ring) => {
+    if (!ring || ring.vertices.length === 0) return;
+    builder.add("move_operation", {
+      x: ring.vertices[0].x,
+      y: mfy(ring.vertices[0].y)
+    });
+    const vertices_loop = [...ring.vertices, ring.vertices[0]];
+    for (let i = 0; i < vertices_loop.length - 1; i++) {
+      const start = vertices_loop[i];
+      const end = vertices_loop[i + 1];
+      if (start.bulge && Math.abs(start.bulge) > 1e-9) {
+        const bulge = (opts.flip_y_axis ? -1 : 1) * start.bulge;
+        if (bulge > 0) {
+          builder.add("set_movement_mode_to_counterclockwise_circular", {});
+        } else {
+          builder.add("set_movement_mode_to_clockwise_circular", {});
+        }
+        const p1 = { x: start.x, y: start.y };
+        const p2 = { x: end.x, y: end.y };
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        const d = Math.sqrt(dx * dx + dy * dy);
+        if (d < 1e-9) {
+          builder.add("set_movement_mode_to_linear", {});
+          builder.add("plot_operation", {
+            x: end.x,
+            y: mfy(end.y)
+          });
+          continue;
+        }
+        const abs_b = Math.abs(bulge);
+        const theta = 4 * Math.atan(abs_b);
+        if (Math.abs(Math.sin(theta / 2)) < 1e-9) {
+          builder.add("set_movement_mode_to_linear", {});
+          builder.add("plot_operation", {
+            x: end.x,
+            y: mfy(end.y)
+          });
+          continue;
+        }
+        const R = d / (2 * Math.sin(theta / 2));
+        const alpha = (Math.PI - theta) / 2;
+        const phi = Math.atan2(dy, dx);
+        const delta_angle = bulge > 0 ? alpha : -alpha;
+        const angle_p1_center = phi + delta_angle;
+        const Cx = p1.x + R * Math.cos(angle_p1_center);
+        const Cy = p1.y + R * Math.sin(angle_p1_center);
+        const i_offset = Cx - p1.x;
+        const j_offset = Cy - p1.y;
+        builder.add("plot_operation", {
+          x: end.x,
+          y: mfy(end.y),
+          i: i_offset,
+          j: opts.flip_y_axis ? -j_offset : j_offset
+        });
+      } else {
+        builder.add("set_movement_mode_to_linear", {});
+        builder.add("plot_operation", { x: end.x, y: mfy(end.y) });
+      }
+    }
+  };
+  const reverseRing = (ring) => {
+    const { vertices } = ring;
+    if (!vertices || vertices.length === 0) return { vertices: [] };
+    const n = vertices.length;
+    const reversed_pts = [...vertices].reverse();
+    const new_vertices = reversed_pts.map((pt, i) => {
+      const bulge_v_idx = (n - 2 - i + n) % n;
+      const bulge = vertices[bulge_v_idx].bulge;
+      return { ...pt, bulge: bulge ? -bulge : void 0 };
+    });
+    return { vertices: new_vertices };
+  };
+  for (const layer of ["top", "bottom"]) {
+    for (const element of soup) {
+      if (element.type === "pcb_copper_pour" && layer === element.layer) {
+        const copper_glayer = glayers[getGerberLayerName(layer, "copper")];
+        const all_pour_commands = [];
+        if (element.shape === "brep") {
+          const { brep_shape } = element;
+          if (!brep_shape) continue;
+          const { outer_ring, inner_rings } = brep_shape;
+          const outer_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+          drawRingToBuilder(outer_builder, reverseRing(outer_ring));
+          outer_builder.add("end_region_statement", {});
+          all_pour_commands.push(...outer_builder.build());
+          if (inner_rings && inner_rings.length > 0) {
+            all_pour_commands.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build()
+            );
+            for (const inner_ring of inner_rings) {
+              const inner_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+              drawRingToBuilder(inner_builder, inner_ring);
+              inner_builder.add("end_region_statement", {});
+              all_pour_commands.push(...inner_builder.build());
+            }
+            all_pour_commands.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "D" }).build()
+            );
+          }
+        } else if (element.shape === "rect") {
+          const { center, width, height, rotation } = element;
+          const w = width / 2;
+          const h = height / 2;
+          const points = [
+            { x: -w, y: h },
+            // Top-left
+            { x: w, y: h },
+            // Top-right
+            { x: w, y: -h },
+            // Bottom-right
+            { x: -w, y: -h }
+            // Bottom-left
+          ];
+          let transformMatrix = identity();
+          if (rotation) {
+            const angle_rad = rotation * Math.PI / 180;
+            transformMatrix = rotate(angle_rad);
+          }
+          transformMatrix = compose(
+            translate(center.x, center.y),
+            transformMatrix
+          );
+          const transformedPoints = points.map(
+            (p) => applyToPoint(transformMatrix, p)
+          );
+          const rect_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+          rect_builder.add("move_operation", {
+            x: transformedPoints[0].x,
+            y: mfy(transformedPoints[0].y)
+          });
+          for (let i = 1; i < transformedPoints.length; i++) {
+            rect_builder.add("plot_operation", {
+              x: transformedPoints[i].x,
+              y: mfy(transformedPoints[i].y)
+            });
+          }
+          rect_builder.add("plot_operation", {
+            x: transformedPoints[0].x,
+            y: mfy(transformedPoints[0].y)
+          });
+          rect_builder.add("end_region_statement", {});
+          all_pour_commands.push(...rect_builder.build());
+        } else if (element.shape === "polygon") {
+          const { points } = element;
+          if (points.length > 0) {
+            const poly_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+            poly_builder.add("move_operation", {
+              x: points[0].x,
+              y: mfy(points[0].y)
+            });
+            for (let i = 1; i < points.length; i++) {
+              poly_builder.add("plot_operation", {
+                x: points[i].x,
+                y: mfy(points[i].y)
+              });
+            }
+            poly_builder.add("plot_operation", {
+              x: points[0].x,
+              y: mfy(points[0].y)
+            });
+            poly_builder.add("end_region_statement", {});
+            all_pour_commands.push(...poly_builder.build());
+          }
+        }
+        copper_glayer.push(...all_pour_commands);
+        if (element.covered_with_solder_mask === false) {
+          const mask_layer = glayers[getGerberLayerName(layer, "soldermask")];
+          mask_layer.push(...all_pour_commands);
+        }
+      }
+    }
+  }
   for (const layer of ["top", "bottom", "edgecut"]) {
     for (const element of soup) {
       if (element.type === "pcb_trace") {
@@ -2044,10 +2218,7 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
           }
         }
       } else if (element.type === "pcb_board" && layer === "edgecut") {
-        const board = element;
-        if (board.pcb_panel_id) {
-          continue;
-        }
+        if (hasPanel) continue;
         const glayer = glayers.Edge_Cuts;
         const { width, height, center, outline } = element;
         const gerberBuild = gerberBuilder().add("select_aperture", {
@@ -2253,164 +2424,6 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
           }
           ec_layer.push(...cutout_builder.build());
         }
-      } else if (element.type === "pcb_copper_pour" && layer === element.layer) {
-        const copper_glayer = glayers[getGerberLayerName(layer, "copper")];
-        const pour_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
-        if (element.shape === "brep") {
-          const { brep_shape } = element;
-          if (!brep_shape) continue;
-          const { outer_ring, inner_rings } = brep_shape;
-          const drawRing = (ring) => {
-            if (!ring || ring.vertices.length === 0) return;
-            pour_builder.add("move_operation", {
-              x: ring.vertices[0].x,
-              y: mfy(ring.vertices[0].y)
-            });
-            const vertices_loop = [...ring.vertices, ring.vertices[0]];
-            for (let i = 0; i < vertices_loop.length - 1; i++) {
-              const start = vertices_loop[i];
-              const end = vertices_loop[i + 1];
-              if (start.bulge && Math.abs(start.bulge) > 1e-9) {
-                const bulge = (opts.flip_y_axis ? -1 : 1) * start.bulge;
-                if (bulge > 0) {
-                  pour_builder.add(
-                    "set_movement_mode_to_counterclockwise_circular",
-                    {}
-                  );
-                } else {
-                  pour_builder.add(
-                    "set_movement_mode_to_clockwise_circular",
-                    {}
-                  );
-                }
-                const p1 = { x: start.x, y: start.y };
-                const p2 = { x: end.x, y: end.y };
-                const dx = p2.x - p1.x;
-                const dy = p2.y - p1.y;
-                const d = Math.sqrt(dx * dx + dy * dy);
-                if (d < 1e-9) {
-                  pour_builder.add("set_movement_mode_to_linear", {});
-                  pour_builder.add("plot_operation", {
-                    x: end.x,
-                    y: mfy(end.y)
-                  });
-                  continue;
-                }
-                const abs_b = Math.abs(bulge);
-                const theta = 4 * Math.atan(abs_b);
-                if (Math.abs(Math.sin(theta / 2)) < 1e-9) {
-                  pour_builder.add("set_movement_mode_to_linear", {});
-                  pour_builder.add("plot_operation", {
-                    x: end.x,
-                    y: mfy(end.y)
-                  });
-                  continue;
-                }
-                const R = d / (2 * Math.sin(theta / 2));
-                const alpha = (Math.PI - theta) / 2;
-                const phi = Math.atan2(dy, dx);
-                const delta_angle = bulge > 0 ? alpha : -alpha;
-                const angle_p1_center = phi + delta_angle;
-                const Cx = p1.x + R * Math.cos(angle_p1_center);
-                const Cy = p1.y + R * Math.sin(angle_p1_center);
-                const i_offset = Cx - p1.x;
-                const j_offset = Cy - p1.y;
-                pour_builder.add("plot_operation", {
-                  x: end.x,
-                  y: mfy(end.y),
-                  i: i_offset,
-                  j: opts.flip_y_axis ? -j_offset : j_offset
-                });
-              } else {
-                pour_builder.add("set_movement_mode_to_linear", {});
-                pour_builder.add("plot_operation", { x: end.x, y: mfy(end.y) });
-              }
-            }
-          };
-          const reverseRing = (ring) => {
-            const { vertices } = ring;
-            if (!vertices || vertices.length === 0) return { vertices: [] };
-            const n = vertices.length;
-            const reversed_pts = [...vertices].reverse();
-            const new_vertices = reversed_pts.map((pt, i) => {
-              const bulge_v_idx = (n - 2 - i + n) % n;
-              const bulge = vertices[bulge_v_idx].bulge;
-              return { ...pt, bulge: bulge ? -bulge : void 0 };
-            });
-            return { vertices: new_vertices };
-          };
-          drawRing(reverseRing(outer_ring));
-          if (inner_rings) {
-            for (const inner_ring of inner_rings) {
-              drawRing(reverseRing(inner_ring));
-            }
-          }
-        } else if (element.shape === "rect") {
-          const { center, width, height, rotation } = element;
-          const w = width / 2;
-          const h = height / 2;
-          const points = [
-            { x: -w, y: h },
-            // Top-left
-            { x: w, y: h },
-            // Top-right
-            { x: w, y: -h },
-            // Bottom-right
-            { x: -w, y: -h }
-            // Bottom-left
-          ];
-          let transformMatrix = identity();
-          if (rotation) {
-            const angle_rad = rotation * Math.PI / 180;
-            transformMatrix = rotate(angle_rad);
-          }
-          transformMatrix = compose(
-            translate(center.x, center.y),
-            transformMatrix
-          );
-          const transformedPoints = points.map(
-            (p) => applyToPoint(transformMatrix, p)
-          );
-          pour_builder.add("move_operation", {
-            x: transformedPoints[0].x,
-            y: mfy(transformedPoints[0].y)
-          });
-          for (let i = 1; i < transformedPoints.length; i++) {
-            pour_builder.add("plot_operation", {
-              x: transformedPoints[i].x,
-              y: mfy(transformedPoints[i].y)
-            });
-          }
-          pour_builder.add("plot_operation", {
-            x: transformedPoints[0].x,
-            y: mfy(transformedPoints[0].y)
-          });
-        } else if (element.shape === "polygon") {
-          const { points } = element;
-          if (points.length > 0) {
-            pour_builder.add("move_operation", {
-              x: points[0].x,
-              y: mfy(points[0].y)
-            });
-            for (let i = 1; i < points.length; i++) {
-              pour_builder.add("plot_operation", {
-                x: points[i].x,
-                y: mfy(points[i].y)
-              });
-            }
-            pour_builder.add("plot_operation", {
-              x: points[0].x,
-              y: mfy(points[0].y)
-            });
-          }
-        }
-        pour_builder.add("end_region_statement", {});
-        const pour_commands = pour_builder.build();
-        copper_glayer.push(...pour_commands);
-        if (element.covered_with_solder_mask === false) {
-          const mask_layer = glayers[getGerberLayerName(layer, "soldermask")];
-          mask_layer.push(...pour_commands);
-        }
       }
     }
   }
@@ -2432,4 +2445,4 @@ export {
   stringifyGerberCommands,
   convertSoupToGerberCommands
 };
-//# sourceMappingURL=chunk-WSRKOLQZ.js.map
+//# sourceMappingURL=chunk-VM5XFQ53.js.map