circuit-json-to-gerber 0.0.59 → 0.0.61

package/dist/{chunk-GEJL7TY6.js → chunk-KJYUL256.js}

@@ -395,6 +395,35 @@ var getFileFunctionLayerSpan = ({
   const span = normalizeLayerSpan(requestedLayerSpan, layerCount);
   return `Plated,${getLayerNumber(span.from_layer, layerCount)},${getLayerNumber(span.to_layer, layerCount)},PTH`;
 };
+var getTraceRouteViaElements = (circuitJson) => {
+  const routeVias = [];
+  for (const element of circuitJson) {
+    if (element.type !== "pcb_trace") {
+      continue;
+    }
+    for (const [index, point] of element.route.entries()) {
+      if (point.route_type !== "via" || typeof point.hole_diameter !== "number" || typeof point.outer_diameter !== "number") {
+        continue;
+      }
+      routeVias.push({
+        type: "pcb_via",
+        pcb_via_id: `${element.pcb_trace_id}_route_via_${index}`,
+        x: point.x,
+        y: point.y,
+        hole_diameter: point.hole_diameter,
+        outer_diameter: point.outer_diameter,
+        from_layer: point.from_layer,
+        to_layer: point.to_layer,
+        layers: [point.from_layer, point.to_layer]
+      });
+    }
+  }
+  return routeVias;
+};
+var getDrillableElements = (circuitJson) => [
+  ...circuitJson,
+  ...getTraceRouteViaElements(circuitJson)
+];
 var convertSoupToExcellonDrillCommands = ({
   circuitJson,
   is_plated,
@@ -403,6 +432,7 @@ var convertSoupToExcellonDrillCommands = ({
 }) => {
   const builder = excellonDrill();
   const layerCount = getLayerCount(circuitJson);
+  const drillableElements = getDrillableElements(circuitJson);
   builder.add("M48", {});
   const date_str = (/* @__PURE__ */ new Date()).toISOString();
   builder.add("header_comment", {
@@ -425,7 +455,7 @@ var convertSoupToExcellonDrillCommands = ({
   }).add("FMAT", { format: 2 }).add("unit_format", { unit: "METRIC", lz: null });
   let tool_counter = 10;
   const diameterToToolNumber = {};
-  for (const element of circuitJson) {
+  for (const element of drillableElements) {
     if (!shouldIncludeElement({
       element,
       is_plated,
@@ -453,7 +483,7 @@ var convertSoupToExcellonDrillCommands = ({
   builder.add("G05", {});
   for (let i = 10; i < tool_counter; i++) {
     builder.add("use_tool", { tool_number: i });
-    for (const element of circuitJson) {
+    for (const element of drillableElements) {
       if (element.type === "pcb_plated_hole" || element.type === "pcb_hole" || element.type === "pcb_via") {
         if (!shouldIncludeElement({
           element,
@@ -540,13 +570,15 @@ var convertSoupToExcellonDrillCommandLayers = ({
 }) => {
   const layerCount = getLayerCount(circuitJson);
   const platedSpans = new Map(
-    circuitJson.flatMap((element) => {
-      const span = getPlatedElementLayerSpan(element, layerCount);
-      if (!span) {
-        return [];
+    getDrillableElements(circuitJson).flatMap(
+      (element) => {
+        const span = getPlatedElementLayerSpan(element, layerCount);
+        if (!span) {
+          return [];
+        }
+        return [[getDrillLayerSpanKey(span, layerCount), span]];
       }
-      return [[getDrillLayerSpanKey(span, layerCount), span]];
-    })
+    )
   );
   const platedDrillLayers = Object.fromEntries(
     [...platedSpans.entries()].sort().map(([spanKey, span]) => [
@@ -1347,10 +1379,11 @@ function defineAperturesForLayer({
       }).build()
     );
   }
-  const apertureConfigs = getAllApertureTemplateConfigsForLayer(
+  const apertureConfigs = getAllApertureTemplateConfigsForLayer({
     circuitJson,
-    layerRef
-  );
+    layer: layerRef,
+    glayer_name
+  });
   for (const apertureConfig of apertureConfigs) {
     glayer.push(
       ...gerberBuilder().add("define_aperture_template", {
@@ -1389,6 +1422,36 @@ var getApertureConfigFromPcbSmtpad = (elm) => {
   }
   throw new Error(`Unsupported shape ${elm.shape}`);
 };
+var getApertureConfigFromPcbSmtpadSoldermask = (elm) => {
+  let soldermaskMargin = 0;
+  if ("soldermask_margin" in elm && typeof elm.soldermask_margin === "number") {
+    soldermaskMargin = elm.soldermask_margin;
+  }
+  if (elm.shape === "rect") {
+    return {
+      standard_template_code: "R",
+      x_size: elm.width + soldermaskMargin * 2,
+      y_size: elm.height + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "circle") {
+    return {
+      standard_template_code: "C",
+      diameter: elm.radius * 2 + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "rotated_rect") {
+    return {
+      standard_template_code: "R",
+      x_size: elm.width + soldermaskMargin * 2,
+      y_size: elm.height + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "polygon") {
+    throw new Error("Polygon SMT pads are drawn as regions, not apertures");
+  }
+  throw new Error(`Unsupported shape ${elm.shape}`);
+};
 var getApertureConfigFromPcbSilkscreenPath = (elm) => {
   if ("stroke_width" in elm) {
     return {
@@ -1527,10 +1590,10 @@ var getApertureConfigFromCirclePcbHole = (elm) => {
     diameter: elm.hole_diameter
   };
 };
-var getApertureConfigFromPcbVia = (elm) => {
-  if (!("outer_diameter" in elm)) {
+var getApertureConfigFromOuterDiameter = (elm) => {
+  if (typeof elm.outer_diameter !== "number") {
     throw new Error(
-      "outer_diameter not specified in getApertureConfigFromPcbVia"
+      "outer_diameter not specified in getApertureConfigFromOuterDiameter"
     );
   }
   return {
@@ -1538,9 +1601,14 @@ var getApertureConfigFromPcbVia = (elm) => {
     diameter: elm.outer_diameter
   };
 };
-function getAllApertureTemplateConfigsForLayer(circuitJson, layer) {
+function getAllApertureTemplateConfigsForLayer({
+  circuitJson,
+  layer,
+  glayer_name
+}) {
   const configs = [];
   const configHashMap = /* @__PURE__ */ new Set();
+  const isSoldermaskLayer = glayer_name.endsWith("_Mask");
   const addConfigIfNew = (config) => {
     const hash = stableStringify(config);
     if (!configHashMap.has(hash)) {
@@ -1551,7 +1619,11 @@ function getAllApertureTemplateConfigsForLayer(circuitJson, layer) {
   for (const elm of circuitJson) {
     if (elm.type === "pcb_smtpad") {
       if (elm.layer === layer && elm.shape !== "polygon") {
-        addConfigIfNew(getApertureConfigFromPcbSmtpad(elm));
+        if (isSoldermaskLayer) {
+          addConfigIfNew(getApertureConfigFromPcbSmtpadSoldermask(elm));
+        } else {
+          addConfigIfNew(getApertureConfigFromPcbSmtpad(elm));
+        }
       }
     } else if (elm.type === "pcb_solder_paste") {
       if (elm.layer === layer) {
@@ -1568,14 +1640,26 @@ function getAllApertureTemplateConfigsForLayer(circuitJson, layer) {
       }
     } else if (elm.type === "pcb_plated_hole") {
       if (elm.layers.includes(layer)) {
+        if (glayer_name.endsWith("_Mask") && elm.is_covered_with_solder_mask === true) {
+          continue;
+        }
         addConfigIfNew(getApertureConfigFromPcbPlatedHole(elm));
       }
     } else if (elm.type === "pcb_hole") {
+      if (glayer_name.endsWith("_Mask") && elm.is_covered_with_solder_mask === true) {
+        continue;
+      }
       if (elm.hole_shape === "circle")
         addConfigIfNew(getApertureConfigFromCirclePcbHole(elm));
       else console.warn("NOT IMPLEMENTED: drawing gerber for non circle holes");
     } else if (elm.type === "pcb_via") {
-      addConfigIfNew(getApertureConfigFromPcbVia(elm));
+      addConfigIfNew(getApertureConfigFromOuterDiameter(elm));
+    } else if (elm.type === "pcb_trace") {
+      for (const point of elm.route) {
+        if (point.route_type === "via" && typeof point.outer_diameter === "number" && (point.from_layer === layer || point.to_layer === layer)) {
+          addConfigIfNew(getApertureConfigFromOuterDiameter(point));
+        }
+      }
     } else if (elm.type === "pcb_silkscreen_path")
       addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
     else if (elm.type === "pcb_silkscreen_text")
@@ -1614,7 +1698,7 @@ var findApertureNumber = (glayer, search_params) => {
 // package.json
 var package_default = {
   name: "circuit-json-to-gerber",
-  version: "0.0.58",
+  version: "0.0.60",
   main: "dist/index.js",
   type: "module",
   scripts: {
@@ -2194,6 +2278,30 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
                 }).add("move_operation", { x: a.x, y: mfy(a.y) }).add("plot_operation", { x: b.x, y: mfy(b.y) }).build()
               );
             }
+          } else if (a.route_type === "via" && b.route_type === "wire") {
+            if (b.layer === layer) {
+              const glayer = glayers[getGerberLayerName(layer, "copper")];
+              glayer.push(
+                ...gerberBuilder().add("select_aperture", {
+                  aperture_number: findApertureNumber(glayer, {
+                    trace_width: b.width
+                  })
+                }).add("move_operation", { x: a.x, y: mfy(a.y) }).add("plot_operation", { x: b.x, y: mfy(b.y) }).build()
+              );
+            }
+          }
+        }
+        for (const point of route) {
+          if (point.route_type === "via" && typeof point.outer_diameter === "number" && (point.from_layer === layer || point.to_layer === layer)) {
+            const glayer = glayers[getGerberLayerName(layer, "copper")];
+            glayer.push(
+              ...gerberBuilder().add("select_aperture", {
+                aperture_number: findApertureNumber(
+                  glayer,
+                  getApertureConfigFromOuterDiameter(point)
+                )
+              }).add("flash_operation", { x: point.x, y: mfy(point.y) }).build()
+            );
           }
         }
       } else if (element.type === "pcb_silkscreen_path" && outerLayerRefs.includes(layer)) {
@@ -2233,11 +2341,16 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
         );
       } else if (element.type === "pcb_smtpad" && element.shape !== "polygon") {
         if (element.layer === layer && outerLayerRefs.includes(layer)) {
-          for (const glayer of [
-            glayers[getGerberLayerName(layer, "copper")],
-            glayers[getGerberLayerName(layer, "soldermask")]
+          for (const { glayer, apertureConfig } of [
+            {
+              glayer: glayers[getGerberLayerName(layer, "copper")],
+              apertureConfig: getApertureConfigFromPcbSmtpad(element)
+            },
+            {
+              glayer: glayers[getGerberLayerName(layer, "soldermask")],
+              apertureConfig: getApertureConfigFromPcbSmtpadSoldermask(element)
+            }
           ]) {
-            const apertureConfig = getApertureConfigFromPcbSmtpad(element);
             const apertureNumber = findApertureNumber(glayer, apertureConfig);
             const gb = gerberBuilder().add("select_aperture", {
               aperture_number: apertureNumber
@@ -2330,7 +2443,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           const layersToAddTo = [
             glayers[getGerberLayerName(layer, "copper")]
           ];
-          if (outerLayerRefs.includes(layer)) {
+          if (outerLayerRefs.includes(layer) && element.is_covered_with_solder_mask !== true) {
             layersToAddTo.push(glayers[getGerberLayerName(layer, "soldermask")]);
           }
           for (const glayer of layersToAddTo) {
@@ -2438,7 +2551,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
         }
       } else if (element.type === "pcb_hole") {
-        if (outerLayerRefs.includes(layer)) {
+        if (outerLayerRefs.includes(layer) && element.is_covered_with_solder_mask !== true) {
           for (const glayer of [
             glayers[getGerberLayerName(layer, "soldermask")]
           ]) {
@@ -2471,7 +2584,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
               ...gerberBuilder().add("select_aperture", {
                 aperture_number: findApertureNumber(
                   glayer,
-                  getApertureConfigFromPcbVia(element)
+                  getApertureConfigFromOuterDiameter(element)
                 )
               }).add("flash_operation", { x: element.x, y: mfy(element.y) }).build()
             );
@@ -2706,4 +2819,4 @@ export {
   stringifyGerberCommands,
   convertSoupToGerberCommands
 };
-//# sourceMappingURL=chunk-GEJL7TY6.js.map
+//# sourceMappingURL=chunk-KJYUL256.js.map