lbrnts 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -205,13 +205,13 @@ type Mat = [
 declare abstract class ShapeBase extends LightBurnBaseElement {
     cutIndex?: number;
     locked?: boolean;
-    xform?: Mat;
+    xform: Mat;
     protected getShapeXmlAttributes(): Record<string, string | number | boolean | undefined>;
     getChildren(): LightBurnBaseElement[];
     static readCommon(node: XmlJsonElement): {
         cutIndex?: number;
         locked?: boolean;
-        xform?: Mat;
+        xform: Mat;
     };
 }
 
@@ -263,15 +263,22 @@ declare class ShapePath extends ShapeBase {
     static fromXmlJson(node: XmlJsonElement): ShapePath;
     /**
      * Parse encoded VertList string format
-     * Format: V{x} {y}c{flag}x{flag}c{flag}x{c1x}c{flag}y{c1y}...
+     * Format: V{x} {y}c{flag}c0x{value}c0y{value}c1x{value}c1y{value}
      * Example: V2.1156745 -12.3306c0x1c1x1.5871694c1y-12.3306
      *
      * Control points are encoded as:
-     * - c0x{value}c0y{value} = control point 0 (when both present)
-     * - c1x{value}c1y{value} = control point 1 (when both present)
-     * - c{num}x{num} alone (like c0x1) = flag, not a coordinate
+     * - c0x{value}c0y{value} = control point 0 (outgoing handle when this vertex is START of Bezier)
+     * - c1x{value}c1y{value} = control point 1 (incoming handle when this vertex is END of Bezier)
+     * - c0x1 or c1x1 (value of exactly "1" without corresponding y) = "no handle" marker, not a coordinate
      */
     static parseEncodedVertList(encoded: string): Vert[];
+    /**
+     * Parse encoded PrimList string format
+     * Format: {type}{fromIdx} {toIdx}{type}{fromIdx} {toIdx}...
+     * Example: L0 1B1 2L2 3B3 4
+     * where L = Line (type 0), B = Bezier (type 1)
+     */
+    static parseEncodedPrimList(encoded: string): Prim[];
     /**
      * Parse encoded PrimPolyline string format
      * This typically contains line-to commands, each prim is type 0 (LineTo)

package/dist/index.js

@@ -637,7 +637,8 @@ LightBurnBaseElement.register("Thumbnail", Thumbnail);
 var ShapeBase = class extends LightBurnBaseElement {
   cutIndex;
   locked;
-  xform;
+  xform = [1, 0, 0, 1, 0, 0];
+  // Default identity matrix
   getShapeXmlAttributes() {
     return {
       CutIndex: this.cutIndex,
@@ -646,14 +647,15 @@ var ShapeBase = class extends LightBurnBaseElement {
   }
   getChildren() {
     const children = [];
-    if (this.xform) {
-      const xformElement = new XFormElement(this.xform);
-      children.push(xformElement);
-    }
+    const xformElement = new XFormElement(this.xform);
+    children.push(xformElement);
     return children;
   }
   static readCommon(node) {
-    const common = {};
+    const common = {
+      xform: [1, 0, 0, 1, 0, 0]
+      // Default identity matrix
+    };
     if (node.$) {
       if (node.$.CutIndex !== void 0) {
         common.cutIndex = num(node.$.CutIndex, void 0);
@@ -777,7 +779,7 @@ var ShapePath = class _ShapePath extends ShapeBase {
       children.push(new VertListElement(this.verts));
     }
     if (this.prims.length > 0) {
-      children.push(new PrimListElement(this.prims, this.isClosed));
+      children.push(new PrimListElement(this.prims));
     }
     return children;
   }
@@ -813,11 +815,15 @@ var ShapePath = class _ShapePath extends ShapeBase {
     const primList = node.PrimList;
     if (primList) {
       if (typeof primList === "string") {
-        const isOpen = primList.includes("Open");
-        path.isClosed = !isOpen;
-        const primCount = isOpen ? path.verts.length - 1 : path.verts.length;
-        for (let i = 0; i < primCount; i++) {
-          path.prims.push({ type: 0 });
+        if (primList.match(/[LB]\d+\s+\d+/)) {
+          path.prims = _ShapePath.parseEncodedPrimList(primList);
+        } else if (primList.includes("Line")) {
+          const isOpen = primList.includes("Open");
+          path.isClosed = !isOpen;
+          const primCount = isOpen ? path.verts.length - 1 : path.verts.length;
+          for (let i = 0; i < primCount; i++) {
+            path.prims.push({ type: 0 });
+          }
         }
       } else if (primList.Prim) {
         const prims = Array.isArray(primList.Prim) ? primList.Prim : [primList.Prim];
@@ -856,13 +862,13 @@ var ShapePath = class _ShapePath extends ShapeBase {
   }
   /**
    * Parse encoded VertList string format
-   * Format: V{x} {y}c{flag}x{flag}c{flag}x{c1x}c{flag}y{c1y}...
+   * Format: V{x} {y}c{flag}c0x{value}c0y{value}c1x{value}c1y{value}
    * Example: V2.1156745 -12.3306c0x1c1x1.5871694c1y-12.3306
    *
    * Control points are encoded as:
-   * - c0x{value}c0y{value} = control point 0 (when both present)
-   * - c1x{value}c1y{value} = control point 1 (when both present)
-   * - c{num}x{num} alone (like c0x1) = flag, not a coordinate
+   * - c0x{value}c0y{value} = control point 0 (outgoing handle when this vertex is START of Bezier)
+   * - c1x{value}c1y{value} = control point 1 (incoming handle when this vertex is END of Bezier)
+   * - c0x1 or c1x1 (value of exactly "1" without corresponding y) = "no handle" marker, not a coordinate
    */
   static parseEncodedVertList(encoded) {
     const verts = [];
@@ -879,13 +885,13 @@ var ShapePath = class _ShapePath extends ShapeBase {
         }
         const c0xMatch = part.match(/c0x([-\d.]+)/);
         const c0yMatch = part.match(/c0y([-\d.]+)/);
-        const c1xMatch = part.match(/c1x([-\d.]+)/);
-        const c1yMatch = part.match(/c1y([-\d.]+)/);
-        if (c0xMatch && c0yMatch && (c0xMatch[1].includes(".") || c0xMatch[1].length > 1)) {
+        if (c0xMatch && c0yMatch) {
           vert.c0x = parseFloat(c0xMatch[1]);
           vert.c0y = parseFloat(c0yMatch[1]);
         }
-        if (c1xMatch && c1yMatch && (c1xMatch[1].includes(".") || c1xMatch[1].length > 1)) {
+        const c1xMatch = part.match(/c1x([-\d.]+)/);
+        const c1yMatch = part.match(/c1y([-\d.]+)/);
+        if (c1xMatch && c1yMatch) {
           vert.c1x = parseFloat(c1xMatch[1]);
           vert.c1y = parseFloat(c1yMatch[1]);
         }
@@ -894,6 +900,25 @@ var ShapePath = class _ShapePath extends ShapeBase {
     }
     return verts;
   }
+  /**
+   * Parse encoded PrimList string format
+   * Format: {type}{fromIdx} {toIdx}{type}{fromIdx} {toIdx}...
+   * Example: L0 1B1 2L2 3B3 4
+   * where L = Line (type 0), B = Bezier (type 1)
+   */
+  static parseEncodedPrimList(encoded) {
+    const prims = [];
+    const primPattern = /([LB])(\d+)\s+(\d+)/g;
+    const matches = encoded.matchAll(primPattern);
+    for (const match of matches) {
+      const primType = match[1];
+      prims.push({
+        type: primType === "L" ? 0 : 1
+        // L=0 (Line), B=1 (Bezier)
+      });
+    }
+    return prims;
+  }
   /**
    * Parse encoded PrimPolyline string format
    * This typically contains line-to commands, each prim is type 0 (LineTo)
@@ -939,49 +964,46 @@ var VertListElement = class extends LightBurnBaseElement {
   }
   toXml(indent = 0) {
     const indentStr = "    ".repeat(indent);
-    const innerIndent = "    ".repeat(indent + 1);
-    const lines = [`${indentStr}<VertList>`];
+    let encoded = "";
     for (const vert of this.verts) {
-      let attrs = `x="${vert.x}" y="${vert.y}"`;
+      encoded += `V${vert.x} ${vert.y}`;
       if (vert.c !== void 0) {
-        attrs += ` c="${vert.c}"`;
+        encoded += `c${vert.c}`;
       }
       if (vert.c0x !== void 0) {
-        attrs += ` c0x="${vert.c0x}"`;
+        encoded += `c0x${vert.c0x}`;
       }
       if (vert.c0y !== void 0) {
-        attrs += ` c0y="${vert.c0y}"`;
+        encoded += `c0y${vert.c0y}`;
       }
       if (vert.c1x !== void 0) {
-        attrs += ` c1x="${vert.c1x}"`;
+        encoded += `c1x${vert.c1x}`;
       }
       if (vert.c1y !== void 0) {
-        attrs += ` c1y="${vert.c1y}"`;
+        encoded += `c1y${vert.c1y}`;
       }
-      lines.push(`${innerIndent}<Vert ${attrs}/>`);
     }
-    lines.push(`${indentStr}</VertList>`);
-    return lines.join("\n");
+    return `${indentStr}<VertList>${encoded}</VertList>`;
   }
 };
 var PrimListElement = class extends LightBurnBaseElement {
   prims;
-  isClosed;
-  constructor(prims, isClosed) {
+  constructor(prims) {
     super();
     this.token = "PrimList";
     this.prims = prims;
-    this.isClosed = isClosed;
   }
   toXml(indent = 0) {
     const indentStr = "    ".repeat(indent);
-    const innerIndent = "    ".repeat(indent + 1);
-    const lines = [`${indentStr}<PrimList>`];
-    for (const prim of this.prims) {
-      lines.push(`${innerIndent}<Prim type="${prim.type}"/>`);
+    let encoded = "";
+    for (let i = 0; i < this.prims.length; i++) {
+      const prim = this.prims[i];
+      const primType = prim.type === 0 ? "L" : "B";
+      const fromIdx = i;
+      const toIdx = (i + 1) % this.prims.length;
+      encoded += `${primType}${fromIdx} ${toIdx}`;
     }
-    lines.push(`${indentStr}</PrimList>`);
-    return lines.join("\n");
+    return `${indentStr}<PrimList>${encoded}</PrimList>`;
   }
 };
 LightBurnBaseElement.register("Shape.Path", ShapePath);
@@ -1040,7 +1062,8 @@ var ShapeGroup = class _ShapeGroup extends ShapeBase {
     return group;
   }
   getChildren() {
-    return this.children;
+    const baseChildren = super.getChildren();
+    return [...baseChildren, ...this.children];
   }
 };
 LightBurnBaseElement.register("Shape.Group", ShapeGroup);

package/package.json

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