lbrnts 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -317,8 +317,10 @@ declare class ShapeText extends ShapeBase {
 declare class ShapeGroup extends ShapeBase {
     children: LightBurnBaseElement[];
     constructor();
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
     static fromXmlJson(node: XmlJsonElement): ShapeGroup;
     getChildren(): LightBurnBaseElement[];
+    toXml(indent?: number): string;
 }
 
 declare class ShapeBitmap extends ShapeBase {

package/dist/index.js

@@ -1080,11 +1080,17 @@ var ShapeGroup = class _ShapeGroup extends ShapeBase {
     super();
     this.token = "Shape.Group";
   }
+  getXmlAttributes() {
+    return {
+      Type: "Group",
+      ...this.getShapeXmlAttributes()
+    };
+  }
   static fromXmlJson(node) {
     const group = new _ShapeGroup();
     const common = ShapeBase.readCommon(node);
     Object.assign(group, common);
-    const shapes = node.Shape;
+    const shapes = node.Children?.Shape || node.Shape;
     if (shapes) {
       if (Array.isArray(shapes)) {
         for (const shape of shapes) {
@@ -1104,6 +1110,32 @@ var ShapeGroup = class _ShapeGroup extends ShapeBase {
     const baseChildren = super.getChildren();
     return [...baseChildren, ...this.children];
   }
+  toXml(indent = 0) {
+    const indentStr = "    ".repeat(indent);
+    const tag = this.getXmlTag();
+    const attrs = this.getXmlAttributes();
+    const attrPairs = [];
+    for (const [key, value] of Object.entries(attrs)) {
+      if (value !== void 0 && value !== null) {
+        if (typeof value === "boolean") {
+          attrPairs.push(`${key}="${value ? "True" : "False"}"`);
+        } else {
+          attrPairs.push(`${key}="${value}"`);
+        }
+      }
+    }
+    const attrStr = attrPairs.length > 0 ? " " + attrPairs.join(" ") : "";
+    const lines = [`${indentStr}<${tag}${attrStr}>`];
+    const xformXml = super.getChildren()[0].toXml(indent + 1);
+    lines.push(xformXml);
+    lines.push(`${"    ".repeat(indent + 1)}<Children>`);
+    for (const child of this.children) {
+      lines.push(child.toXml(indent + 2));
+    }
+    lines.push(`${"    ".repeat(indent + 1)}</Children>`);
+    lines.push(`${indentStr}</${tag}>`);
+    return lines.join("\n");
+  }
 };
 LightBurnBaseElement.register("Shape.Group", ShapeGroup);
 
@@ -1345,6 +1377,9 @@ function arrayToMatrix(arr) {
 function apply(m, p) {
   return applyToPoint(m, p);
 }
+function mul(m1, m2) {
+  return compose(m1, m2);
+}
 function matToSvg(m) {
   return toSVG(m);
 }
@@ -1678,16 +1713,275 @@ var ellipseRenderer = {
   }
 };
 
+// lib/svg-gen/path-data.ts
+function transformPoint(pt, matrix) {
+  return apply(matrix, pt);
+}
+function shapePathToPathData(path) {
+  const matrix = path.xform ? arrayToMatrix(path.xform) : identity();
+  let d = "";
+  for (let i = 0; i < path.prims.length; i++) {
+    const prim = path.prims[i];
+    const startV = path.verts[i];
+    const endV = path.verts[(i + 1) % path.verts.length];
+    const startPt = transformPoint({ x: startV.x, y: startV.y }, matrix);
+    if (i === 0) {
+      d += `M ${startPt.x} ${startPt.y}`;
+    }
+    if (prim.type === 0) {
+      const endPt = transformPoint({ x: endV.x, y: endV.y }, matrix);
+      d += ` L ${endPt.x} ${endPt.y}`;
+    } else if (prim.type === 1) {
+      const c0x = startV.c0x ?? startV.x;
+      const c0y = startV.c0y ?? startV.y;
+      const c1x = endV.c1x ?? endV.x;
+      const c1y = endV.c1y ?? endV.y;
+      const cp0 = transformPoint({ x: c0x, y: c0y }, matrix);
+      const cp1 = transformPoint({ x: c1x, y: c1y }, matrix);
+      const endPt = transformPoint({ x: endV.x, y: endV.y }, matrix);
+      d += ` C ${cp0.x} ${cp0.y} ${cp1.x} ${cp1.y} ${endPt.x} ${endPt.y}`;
+    }
+  }
+  if (d.length > 0 && path.isClosed) {
+    d += " Z";
+  }
+  return d;
+}
+function rectToPathData(rect) {
+  const matrix = rect.xform ? arrayToMatrix(rect.xform) : identity();
+  const w = rect.w || 0;
+  const h = rect.h || 0;
+  const cr = rect.cr || 0;
+  if (cr > 0) {
+    const r = Math.min(cr, w / 2, h / 2);
+    const p02 = transformPoint({ x: r, y: 0 }, matrix);
+    const p12 = transformPoint({ x: w - r, y: 0 }, matrix);
+    const p22 = transformPoint({ x: w, y: r }, matrix);
+    const p32 = transformPoint({ x: w, y: h - r }, matrix);
+    const p4 = transformPoint({ x: w - r, y: h }, matrix);
+    const p5 = transformPoint({ x: r, y: h }, matrix);
+    const p6 = transformPoint({ x: 0, y: h - r }, matrix);
+    const p7 = transformPoint({ x: 0, y: r }, matrix);
+    const k = 0.5522847498;
+    const cp_tr1 = transformPoint({ x: w - r + r * k, y: 0 }, matrix);
+    const cp_tr2 = transformPoint({ x: w, y: r - r * k }, matrix);
+    const cp_br1 = transformPoint({ x: w, y: h - r + r * k }, matrix);
+    const cp_br2 = transformPoint({ x: w - r + r * k, y: h }, matrix);
+    const cp_bl1 = transformPoint({ x: r - r * k, y: h }, matrix);
+    const cp_bl2 = transformPoint({ x: 0, y: h - r + r * k }, matrix);
+    const cp_tl1 = transformPoint({ x: 0, y: r - r * k }, matrix);
+    const cp_tl2 = transformPoint({ x: r - r * k, y: 0 }, matrix);
+    return `M ${p02.x} ${p02.y} L ${p12.x} ${p12.y} C ${cp_tr1.x} ${cp_tr1.y} ${cp_tr2.x} ${cp_tr2.y} ${p22.x} ${p22.y} L ${p32.x} ${p32.y} C ${cp_br1.x} ${cp_br1.y} ${cp_br2.x} ${cp_br2.y} ${p4.x} ${p4.y} L ${p5.x} ${p5.y} C ${cp_bl1.x} ${cp_bl1.y} ${cp_bl2.x} ${cp_bl2.y} ${p6.x} ${p6.y} L ${p7.x} ${p7.y} C ${cp_tl1.x} ${cp_tl1.y} ${cp_tl2.x} ${cp_tl2.y} ${p02.x} ${p02.y} Z`;
+  }
+  const p0 = transformPoint({ x: 0, y: 0 }, matrix);
+  const p1 = transformPoint({ x: w, y: 0 }, matrix);
+  const p2 = transformPoint({ x: w, y: h }, matrix);
+  const p3 = transformPoint({ x: 0, y: h }, matrix);
+  return `M ${p0.x} ${p0.y} L ${p1.x} ${p1.y} L ${p2.x} ${p2.y} L ${p3.x} ${p3.y} Z`;
+}
+function ellipseToPathData(ellipse) {
+  const matrix = ellipse.xform ? arrayToMatrix(ellipse.xform) : identity();
+  const rx = ellipse.rx || 0;
+  const ry = ellipse.ry || 0;
+  const k = 0.5522847498;
+  const p0 = transformPoint({ x: rx, y: 0 }, matrix);
+  const p1 = transformPoint({ x: 0, y: ry }, matrix);
+  const p2 = transformPoint({ x: -rx, y: 0 }, matrix);
+  const p3 = transformPoint({ x: 0, y: -ry }, matrix);
+  const cp0_1a = transformPoint({ x: rx, y: ry * k }, matrix);
+  const cp0_1b = transformPoint({ x: rx * k, y: ry }, matrix);
+  const cp1_2a = transformPoint({ x: -rx * k, y: ry }, matrix);
+  const cp1_2b = transformPoint({ x: -rx, y: ry * k }, matrix);
+  const cp2_3a = transformPoint({ x: -rx, y: -ry * k }, matrix);
+  const cp2_3b = transformPoint({ x: -rx * k, y: -ry }, matrix);
+  const cp3_0a = transformPoint({ x: rx * k, y: -ry }, matrix);
+  const cp3_0b = transformPoint({ x: rx, y: -ry * k }, matrix);
+  return `M ${p0.x} ${p0.y} C ${cp0_1a.x} ${cp0_1a.y} ${cp0_1b.x} ${cp0_1b.y} ${p1.x} ${p1.y} C ${cp1_2a.x} ${cp1_2a.y} ${cp1_2b.x} ${cp1_2b.y} ${p2.x} ${p2.y} C ${cp2_3a.x} ${cp2_3a.y} ${cp2_3b.x} ${cp2_3b.y} ${p3.x} ${p3.y} C ${cp3_0a.x} ${cp3_0a.y} ${cp3_0b.x} ${cp3_0b.y} ${p0.x} ${p0.y} Z`;
+}
+
 // lib/svg-gen/registry/shape-group.ts
+function isClosedPathShape(shape) {
+  if (shape instanceof ShapePath) {
+    return shape.isClosed;
+  }
+  if (shape instanceof ShapeRect || shape instanceof ShapeEllipse) {
+    return true;
+  }
+  return false;
+}
+function getPathDataForShape(shape, groupMatrix) {
+  if (shape instanceof ShapePath && shape.isClosed) {
+    const originalXform = shape.xform;
+    if (originalXform) {
+      const shapeMatrix = arrayToMatrix(originalXform);
+      const combinedMatrix = mul(groupMatrix, shapeMatrix);
+      shape.xform = [
+        combinedMatrix.a,
+        combinedMatrix.b,
+        combinedMatrix.c,
+        combinedMatrix.d,
+        combinedMatrix.e,
+        combinedMatrix.f
+      ];
+      const pathData2 = shapePathToPathData(shape);
+      shape.xform = originalXform;
+      return pathData2;
+    }
+    shape.xform = [
+      groupMatrix.a,
+      groupMatrix.b,
+      groupMatrix.c,
+      groupMatrix.d,
+      groupMatrix.e,
+      groupMatrix.f
+    ];
+    const pathData = shapePathToPathData(shape);
+    shape.xform = originalXform;
+    return pathData;
+  }
+  if (shape instanceof ShapeRect) {
+    const originalXform = shape.xform;
+    if (originalXform) {
+      const shapeMatrix = arrayToMatrix(originalXform);
+      const combinedMatrix = mul(groupMatrix, shapeMatrix);
+      shape.xform = [
+        combinedMatrix.a,
+        combinedMatrix.b,
+        combinedMatrix.c,
+        combinedMatrix.d,
+        combinedMatrix.e,
+        combinedMatrix.f
+      ];
+      const pathData2 = rectToPathData(shape);
+      shape.xform = originalXform;
+      return pathData2;
+    }
+    shape.xform = [
+      groupMatrix.a,
+      groupMatrix.b,
+      groupMatrix.c,
+      groupMatrix.d,
+      groupMatrix.e,
+      groupMatrix.f
+    ];
+    const pathData = rectToPathData(shape);
+    shape.xform = originalXform;
+    return pathData;
+  }
+  if (shape instanceof ShapeEllipse) {
+    const originalXform = shape.xform;
+    if (originalXform) {
+      const shapeMatrix = arrayToMatrix(originalXform);
+      const combinedMatrix = mul(groupMatrix, shapeMatrix);
+      shape.xform = [
+        combinedMatrix.a,
+        combinedMatrix.b,
+        combinedMatrix.c,
+        combinedMatrix.d,
+        combinedMatrix.e,
+        combinedMatrix.f
+      ];
+      const pathData2 = ellipseToPathData(shape);
+      shape.xform = originalXform;
+      return pathData2;
+    }
+    shape.xform = [
+      groupMatrix.a,
+      groupMatrix.b,
+      groupMatrix.c,
+      groupMatrix.d,
+      groupMatrix.e,
+      groupMatrix.f
+    ];
+    const pathData = ellipseToPathData(shape);
+    shape.xform = originalXform;
+    return pathData;
+  }
+  return null;
+}
 var groupRenderer = {
   match: (s) => s instanceof ShapeGroup,
   bbox: (grp) => {
     return grp.children.filter((c) => c instanceof ShapeBase).reduce((bb, c) => boxUnion(bb, bboxOfShape(c)), emptyBox());
   },
   toSvg: (grp, cutSettings, options) => {
-    const xform = grp.xform ? arrayToMatrix(grp.xform) : identity();
-    const transform = matToSvg(xform);
-    const children = grp.children.filter((c) => c instanceof ShapeBase).map((c) => svgForShape(c, cutSettings, options));
+    const groupMatrix = grp.xform ? arrayToMatrix(grp.xform) : identity();
+    const transform = matToSvg(groupMatrix);
+    const shapeChildren = grp.children.filter(
+      (c) => c instanceof ShapeBase
+    );
+    const allClosedPaths = shapeChildren.every((c) => isClosedPathShape(c));
+    if (allClosedPaths && shapeChildren.length > 0) {
+      const pathDataParts = [];
+      for (const child of shapeChildren) {
+        const pathData = getPathDataForShape(child, groupMatrix);
+        if (pathData) {
+          pathDataParts.push(pathData);
+        }
+      }
+      if (pathDataParts.length > 0) {
+        const combinedPathData = pathDataParts.join(" ");
+        const children2 = [];
+        const firstChild = shapeChildren[0];
+        const cutIndex = firstChild.cutIndex;
+        const stroke = colorForCutIndex(cutIndex);
+        const cutSetting = cutIndex !== void 0 ? cutSettings.get(cutIndex) : void 0;
+        const shouldShowFill = cutSetting && (cutSetting.type === "Scan" || cutSetting.type === "Scan+Cut");
+        if (shouldShowFill && cutSetting) {
+          const bbox = shapeChildren.reduce(
+            (bb, c) => boxUnion(bb, bboxOfShape(c)),
+            emptyBox()
+          );
+          const fillSettings = {
+            interval: cutSetting.interval || 0.1,
+            angle: cutSetting.angle || 0,
+            crossHatch: cutSetting.crossHatch || false
+          };
+          const fillLines = generateScanLines(
+            bbox,
+            fillSettings,
+            stroke,
+            options.strokeWidth
+          );
+          const clipId = `clip-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+          const clipPath = {
+            name: "clipPath",
+            type: "element",
+            value: "",
+            attributes: { id: clipId },
+            children: [
+              leaf("path", {
+                d: combinedPathData,
+                "fill-rule": "nonzero",
+                "clip-rule": "nonzero"
+              })
+            ]
+          };
+          const clippedGroup = {
+            name: "g",
+            type: "element",
+            value: "",
+            attributes: { "clip-path": `url(#${clipId})` },
+            children: fillLines
+          };
+          children2.push(clipPath);
+          children2.push(clippedGroup);
+        }
+        children2.push(
+          leaf("path", {
+            d: combinedPathData,
+            fill: "none",
+            "fill-rule": "nonzero",
+            stroke,
+            "stroke-width": String(options.strokeWidth)
+          })
+        );
+        return g({}, children2);
+      }
+    }
+    const children = shapeChildren.map(
+      (c) => svgForShape(c, cutSettings, options)
+    );
     return g({ transform }, children);
   }
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "lbrnts",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "files": [
     "dist"
   ],