circuit-json-to-gerber 0.0.78 → 0.0.79

package/dist/{chunk-O4SBQLXH.js → chunk-UPPCW5VE.js}

@@ -1576,6 +1576,33 @@ var getApertureConfigFromPcbCopperText = (elm) => {
   }
   throw new Error(`Provide font_size for: ${elm}`);
 };
+var getApertureConfigFromPcbFabricationNoteText = (elm) => {
+  if ("font_size" in elm) {
+    return {
+      standard_template_code: "C",
+      diameter: elm.font_size / 8
+    };
+  }
+  throw new Error(`Provide font_size for: ${elm}`);
+};
+var getApertureConfigFromPcbFabricationNotePath = (elm) => {
+  if (!("stroke_width" in elm) || typeof elm.stroke_width !== "number") {
+    return {
+      standard_template_code: "C",
+      diameter: 0.1
+    };
+  }
+  return {
+    standard_template_code: "C",
+    diameter: elm.stroke_width
+  };
+};
+var getApertureConfigFromPcbFabricationNoteDimension = (elm) => {
+  return {
+    standard_template_code: "C",
+    diameter: Math.max(0.05, elm.font_size / 10)
+  };
+};
 var getApertureConfigFromPcbSolderPaste = (elm) => {
   if (elm.shape === "rect") {
     return {
@@ -1778,6 +1805,7 @@ function getAllApertureTemplateConfigsForLayer({
   const configHashMap = /* @__PURE__ */ new Set();
   const isSoldermaskLayer = glayer_name.endsWith("_Mask");
   const isCopperLayer = glayer_name.endsWith("_Cu");
+  const isFabricationLayer = glayer_name.endsWith("_Fab");
   const addConfigIfNew = (config) => {
     const hash = stableStringify(config);
     if (!configHashMap.has(hash)) {
@@ -1787,6 +1815,7 @@ function getAllApertureTemplateConfigsForLayer({
   };
   for (const elm of circuitJson) {
     if (elm.type === "pcb_smtpad") {
+      if (isFabricationLayer) continue;
       if (elm.layer === layer && elm.shape !== "polygon") {
         if (isSoldermaskLayer) {
           addConfigIfNew(getApertureConfigFromPcbSmtpadSoldermask(elm));
@@ -1795,6 +1824,7 @@ function getAllApertureTemplateConfigsForLayer({
         }
       }
     } else if (elm.type === "pcb_solder_paste") {
+      if (isFabricationLayer) continue;
       if (elm.layer === layer) {
         addConfigIfNew(getApertureConfigFromPcbSolderPaste(elm));
         if (elm.shape === "pill") {
@@ -1808,6 +1838,7 @@ function getAllApertureTemplateConfigsForLayer({
         }
       }
     } else if (elm.type === "pcb_plated_hole") {
+      if (isFabricationLayer) continue;
       if (elm.layers.includes(layer)) {
         if (elm.shape === "hole_with_polygon_pad") {
           continue;
@@ -1835,18 +1866,39 @@ function getAllApertureTemplateConfigsForLayer({
       } else
         console.warn("NOT IMPLEMENTED: drawing gerber for non circle holes");
     } else if (elm.type === "pcb_via") {
+      if (isFabricationLayer) continue;
       addConfigIfNew(getApertureConfigFromOuterDiameter(elm));
     } else if (elm.type === "pcb_trace") {
+      if (isFabricationLayer) continue;
       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")
-      addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
-    else if (elm.type === "pcb_copper_text") {
+    } else if (elm.type === "pcb_silkscreen_path") {
+      if (!isFabricationLayer)
+        addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
+    } else if (elm.type === "pcb_silkscreen_text") {
+      if (!isFabricationLayer)
+        addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
+    } else if (elm.type === "pcb_fabrication_note_text") {
+      if (isFabricationLayer && elm.layer === layer)
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteText(elm));
+    } else if (elm.type === "pcb_fabrication_note_path") {
+      if (isFabricationLayer && elm.layer === layer)
+        addConfigIfNew(getApertureConfigFromPcbFabricationNotePath(elm));
+    } else if (elm.type === "pcb_fabrication_note_rect") {
+      if (isFabricationLayer && elm.layer === layer) {
+        if (elm.has_stroke !== false)
+          addConfigIfNew(getApertureConfigFromPcbFabricationNotePath(elm));
+        if (elm.is_filled === true) addConfigIfNew(REGION_APERTURE_CONFIG);
+      }
+    } else if (elm.type === "pcb_fabrication_note_dimension") {
+      if (isFabricationLayer && elm.layer === layer) {
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteDimension(elm));
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteText(elm));
+      }
+    } else if (elm.type === "pcb_copper_text") {
       if (elm.layer === layer)
         addConfigIfNew(getApertureConfigFromPcbCopperText(elm));
     }
@@ -1901,7 +1953,7 @@ var findApertureNumber = (glayer, search_params) => {
 // package.json
 var package_default = {
   name: "circuit-json-to-gerber",
-  version: "0.0.77",
+  version: "0.0.78",
   main: "dist/index.js",
   type: "module",
   scripts: {
@@ -1956,6 +2008,8 @@ var layerAndTypeToFileFunction = {
   "bottom-soldermask": "Soldermask,Bot",
   "top-silkscreen": "Legend,Top",
   "bottom-silkscreen": "Legend,Bot",
+  "top-fabrication": "Other,Fab,Top",
+  "bottom-fabrication": "Other,Fab,Bot",
   "top-paste": "Paste,Top",
   "bottom-paste": "Paste,Bot",
   edgecut: "Profile,NP"
@@ -2018,6 +2072,7 @@ var layerRefToGerberPrefix = {
 var layerTypeToGerberSuffix = {
   copper: "Cu",
   silkscreen: "SilkScreen",
+  fabrication: "Fab",
   soldermask: "Mask",
   mask: "Mask",
   paste: "Paste"
@@ -2115,6 +2170,176 @@ import {
   rotate,
   translate
 } from "transformation-matrix";
+
+// src/gerber/convert-soup-to-gerber-commands/fabricationLayerRefs.ts
+var outerLayerRefs = ["top", "bottom"];
+var isOuterLayerRef = (layerRef) => layerRef === "top" || layerRef === "bottom";
+var isFabricationElementOnLayer = (element, layerRef) => (element.type === "pcb_fabrication_note_text" || element.type === "pcb_fabrication_note_path" || element.type === "pcb_fabrication_note_rect" || element.type === "pcb_fabrication_note_dimension") && element.layer === layerRef;
+var getFabricationLayerRefs = (circuitJson) => outerLayerRefs.filter(
+  (layerRef) => circuitJson.some(
+    (element) => isFabricationElementOnLayer(element, layerRef)
+  )
+);
+
+// src/gerber/convert-soup-to-gerber-commands/getFabRectPoints.ts
+var getFabRectPoints = (element) => {
+  const halfWidth = element.width / 2;
+  const halfHeight = element.height / 2;
+  const { x, y } = element.center;
+  return [
+    { x: x - halfWidth, y: y - halfHeight },
+    { x: x + halfWidth, y: y - halfHeight },
+    { x: x + halfWidth, y: y + halfHeight },
+    { x: x - halfWidth, y: y + halfHeight }
+  ];
+};
+
+// src/gerber/convert-soup-to-gerber-commands/renderOpenPath.ts
+var renderOpenPath = ({
+  element,
+  glayer,
+  apertureConfig,
+  route,
+  mapY
+}) => {
+  if (route.length === 0) return;
+  const gerber = gerberBuilder().add("select_aperture", {
+    aperture_number: findApertureNumber(glayer, apertureConfig)
+  });
+  gerber.add("move_operation", {
+    x: route[0].x,
+    y: mapY(route[0].y)
+  });
+  const isDashed = element.is_stroke_dashed === true;
+  if (!isDashed) {
+    for (let i = 1; i < route.length; i++) {
+      gerber.add("plot_operation", {
+        x: route[i].x,
+        y: mapY(route[i].y)
+      });
+    }
+    glayer.push(...gerber.build());
+    return;
+  }
+  const dashLength = Math.max(0.2, (element.stroke_width ?? 0.1) * 4);
+  const gapLength = dashLength;
+  for (const [start, end] of pairs(route)) {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.hypot(dx, dy);
+    if (length <= 1e-9) continue;
+    const ux = dx / length;
+    const uy = dy / length;
+    let distance = 0;
+    while (distance < length) {
+      const dashEndDistance = Math.min(distance + dashLength, length);
+      const dashStart = {
+        x: start.x + ux * distance,
+        y: start.y + uy * distance
+      };
+      const dashEnd = {
+        x: start.x + ux * dashEndDistance,
+        y: start.y + uy * dashEndDistance
+      };
+      gerber.add("move_operation", {
+        x: dashStart.x,
+        y: mapY(dashStart.y)
+      });
+      gerber.add("plot_operation", {
+        x: dashEnd.x,
+        y: mapY(dashEnd.y)
+      });
+      distance += dashLength + gapLength;
+    }
+  }
+  glayer.push(...gerber.build());
+};
+
+// src/gerber/convert-soup-to-gerber-commands/renderFabricationDimension.ts
+var renderFabricationDimension = ({
+  element,
+  glayer,
+  mapY,
+  renderText
+}) => {
+  const from = element.from;
+  const to = element.to;
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const length = Math.hypot(dx, dy);
+  if (length <= 1e-9) return;
+  const offsetDistance = element.offset_distance ?? element.offset ?? 0;
+  const defaultOffsetDirection = { x: -dy / length, y: dx / length };
+  const offsetDirection = element.offset_direction ?? defaultOffsetDirection;
+  const offsetMagnitude = Math.hypot(offsetDirection.x, offsetDirection.y) || 1;
+  const offsetVector = {
+    x: offsetDirection.x / offsetMagnitude * offsetDistance,
+    y: offsetDirection.y / offsetMagnitude * offsetDistance
+  };
+  const dimStart = { x: from.x + offsetVector.x, y: from.y + offsetVector.y };
+  const dimEnd = { x: to.x + offsetVector.x, y: to.y + offsetVector.y };
+  const arrowSize = element.arrow_size ?? 1;
+  const ux = dx / length;
+  const uy = dy / length;
+  const px = -uy;
+  const py = ux;
+  const arrowHalfWidth = arrowSize * 0.35;
+  const lineConfig = getApertureConfigFromPcbFabricationNoteDimension(element);
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [from, dimStart, dimEnd, to],
+    mapY
+  });
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [
+      {
+        x: dimStart.x + ux * arrowSize + px * arrowHalfWidth,
+        y: dimStart.y + uy * arrowSize + py * arrowHalfWidth
+      },
+      dimStart,
+      {
+        x: dimStart.x + ux * arrowSize - px * arrowHalfWidth,
+        y: dimStart.y + uy * arrowSize - py * arrowHalfWidth
+      }
+    ],
+    mapY
+  });
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [
+      {
+        x: dimEnd.x - ux * arrowSize + px * arrowHalfWidth,
+        y: dimEnd.y - uy * arrowSize + py * arrowHalfWidth
+      },
+      dimEnd,
+      {
+        x: dimEnd.x - ux * arrowSize - px * arrowHalfWidth,
+        y: dimEnd.y - uy * arrowSize - py * arrowHalfWidth
+      }
+    ],
+    mapY
+  });
+  if (element.text) {
+    renderText({
+      ...element,
+      anchor_position: {
+        x: (dimStart.x + dimEnd.x) / 2,
+        y: (dimStart.y + dimEnd.y) / 2
+      },
+      anchor_alignment: "center",
+      ccw_rotation: element.text_ccw_rotation ?? Math.atan2(dy, dx) * 180 / Math.PI
+    });
+  }
+};
+
+// src/gerber/convert-soup-to-gerber-commands/index.ts
 var getLayerCount2 = (circuitJson) => {
   const board = circuitJson.find((element) => element.type === "pcb_board");
   const numLayers = board?.num_layers ?? 2;
@@ -2133,7 +2358,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
   const layerCount = getLayerCount2(circuitJson);
   const innerLayerRefs = getInnerLayerRefs(layerCount);
   const copperLayerRefs = ["top", ...innerLayerRefs, "bottom"];
-  const outerLayerRefs = ["top", "bottom"];
+  const fabricationLayerRefs = getFabricationLayerRefs(circuitJson);
   const glayers = {
     F_Cu: getCommandHeaders({
       layer: "top",
@@ -2180,9 +2405,18 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
       total_layer_count: layerCount
     });
   }
+  for (const layerRef of fabricationLayerRefs) {
+    glayers[getGerberLayerName(layerRef, "fabrication")] = getCommandHeaders({
+      layer: layerRef,
+      layer_type: "fabrication"
+    });
+  }
   const copperGerberLayerNames = copperLayerRefs.map(
     (layerRef) => getGerberLayerName(layerRef, "copper")
   );
+  const fabricationGerberLayerNames = fabricationLayerRefs.map(
+    (layerRef) => getGerberLayerName(layerRef, "fabrication")
+  );
   const outerGerberLayerNames = outerLayerRefs.flatMap((layerRef) => [
     getGerberLayerName(layerRef, "soldermask"),
     getGerberLayerName(layerRef, "paste"),
@@ -2191,6 +2425,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
   for (const glayer_name of [
     "F_Cu",
     ...copperGerberLayerNames.filter((name) => name !== "F_Cu"),
+    ...fabricationGerberLayerNames,
     ...outerGerberLayerNames
   ]) {
     const glayer = glayers[glayer_name];
@@ -2675,7 +2910,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
             );
           }
         }
-      } else if (element.type === "pcb_silkscreen_path" && outerLayerRefs.includes(layer)) {
+      } else if (element.type === "pcb_silkscreen_path" && isOuterLayerRef(layer)) {
         if (element.layer === layer) {
           const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
           const apertureConfig = getApertureConfigFromPcbSilkscreenPath(element);
@@ -2696,13 +2931,65 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
           glayer.push(...gerber.build());
         }
-      } else if (element.type === "pcb_silkscreen_text" && outerLayerRefs.includes(layer)) {
+      } else if (element.type === "pcb_silkscreen_text" && isOuterLayerRef(layer)) {
         renderVectorText(
           element,
           layer,
           "silkscreen",
           getApertureConfigFromPcbSilkscreenText
         );
+      } else if (element.type === "pcb_fabrication_note_path" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          renderOpenPath({
+            element,
+            glayer: glayers[getGerberLayerName(layer, "fabrication")],
+            apertureConfig: getApertureConfigFromPcbFabricationNotePath(element),
+            route: element.route,
+            mapY: mfy
+          });
+        }
+      } else if (element.type === "pcb_fabrication_note_rect" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          const glayer = glayers[getGerberLayerName(layer, "fabrication")];
+          const points = getFabRectPoints(element);
+          if (element.is_filled === true) {
+            addClosedRegionFromPoints({
+              target: glayer,
+              apertureSource: glayer,
+              points
+            });
+          }
+          if (element.has_stroke !== false) {
+            renderOpenPath({
+              element,
+              glayer,
+              apertureConfig: getApertureConfigFromPcbFabricationNotePath(element),
+              route: [...points, points[0]],
+              mapY: mfy
+            });
+          }
+        }
+      } else if (element.type === "pcb_fabrication_note_dimension" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          renderFabricationDimension({
+            element,
+            glayer: glayers[getGerberLayerName(layer, "fabrication")],
+            mapY: mfy,
+            renderText: (textElement) => renderVectorText(
+              textElement,
+              layer,
+              "fabrication",
+              getApertureConfigFromPcbFabricationNoteText
+            )
+          });
+        }
+      } else if (element.type === "pcb_fabrication_note_text" && isOuterLayerRef(layer)) {
+        renderVectorText(
+          element,
+          layer,
+          "fabrication",
+          getApertureConfigFromPcbFabricationNoteText
+        );
       } else if (element.type === "pcb_copper_text" && layer !== "edgecut") {
         renderVectorText(
           element,
@@ -2711,7 +2998,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           getApertureConfigFromPcbCopperText
         );
       } else if (element.type === "pcb_smtpad" && element.shape !== "polygon") {
-        if (element.layer === layer && outerLayerRefs.includes(layer)) {
+        if (element.layer === layer && isOuterLayerRef(layer)) {
           if (element.shape === "pill" || element.shape === "rotated_pill") {
             const soldermaskMargin = typeof element.soldermask_margin === "number" ? element.soldermask_margin : 0;
             const rotation2 = element.shape === "rotated_pill" && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
@@ -2761,7 +3048,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
         }
       } else if (element.type === "pcb_smtpad" && element.shape === "polygon") {
-        if (element.layer === layer && outerLayerRefs.includes(layer)) {
+        if (element.layer === layer && isOuterLayerRef(layer)) {
           const layers_to_add_to = [
             glayers[getGerberLayerName(layer, "copper")]
           ];
@@ -2781,7 +3068,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
         }
       } else if (element.type === "pcb_solder_paste") {
-        if (element.layer === layer && outerLayerRefs.includes(layer)) {
+        if (element.layer === layer && isOuterLayerRef(layer)) {
           const glayer = glayers[getGerberLayerName(layer, "paste")];
           let rotation = 0;
           if ("ccw_rotation" in element && typeof element.ccw_rotation === "number") {
@@ -2823,7 +3110,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           const layersToAddTo = [
             glayers[getGerberLayerName(layer, "copper")]
           ];
-          if (outerLayerRefs.includes(layer) && element.is_covered_with_solder_mask !== true) {
+          if (isOuterLayerRef(layer) && element.is_covered_with_solder_mask !== true) {
             layersToAddTo.push(glayers[getGerberLayerName(layer, "soldermask")]);
           }
           for (const glayer of layersToAddTo) {
@@ -2966,7 +3253,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
         }
       } else if (element.type === "pcb_hole") {
-        if (outerLayerRefs.includes(layer) && element.is_covered_with_solder_mask !== true) {
+        if (isOuterLayerRef(layer) && element.is_covered_with_solder_mask !== true) {
           for (const glayer of [
             glayers[getGerberLayerName(layer, "soldermask")]
           ]) {
@@ -2991,7 +3278,7 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           const layersToAddTo = [
             glayers[getGerberLayerName(layer, "copper")]
           ];
-          if (element.is_tented === false && outerLayerRefs.includes(layer)) {
+          if (element.is_tented === false && isOuterLayerRef(layer)) {
             layersToAddTo.push(glayers[getGerberLayerName(layer, "soldermask")]);
           }
           for (const glayer of layersToAddTo) {
@@ -3234,4 +3521,4 @@ export {
   stringifyGerberCommands,
   convertSoupToGerberCommands
 };
-//# sourceMappingURL=chunk-O4SBQLXH.js.map
+//# sourceMappingURL=chunk-UPPCW5VE.js.map