lbrnts 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -15,6 +15,20 @@ declare class LightBurnBaseElement {
     token: string;
     static token: string;
     getChildren(): LightBurnBaseElement[];
+    /**
+     * Get XML attributes for this element
+     * Subclasses should override this to provide their specific attributes
+     */
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
+    /**
+     * Get the XML tag name for this element
+     * By default, uses the token, but can be overridden
+     */
+    getXmlTag(): string;
+    /**
+     * Convert this element to XML string
+     */
+    toXml(indent?: number): string;
     getStringIndented(): string;
     getString(): string;
     get [Symbol.toStringTag](): string;
@@ -51,6 +65,7 @@ declare class LightBurnProject extends LightBurnBaseElement {
     constructor(init?: LightBurnProjectInit);
     static fromXmlJson(node: XmlJsonElement): LightBurnProject;
     getChildren(): LightBurnBaseElement[];
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
 }
 
 interface CutSettingInit {
@@ -145,6 +160,8 @@ declare class CutSetting extends LightBurnBaseElement {
     set overScanning(value: number | undefined);
     get lineAngle(): number | undefined;
     set lineAngle(value: number | undefined);
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
+    getChildren(): LightBurnBaseElement[];
     static fromXmlJson(node: XmlJsonElement): CutSetting;
 }
 
@@ -189,6 +206,8 @@ declare abstract class ShapeBase extends LightBurnBaseElement {
     cutIndex?: number;
     locked?: boolean;
     xform?: Mat;
+    protected getShapeXmlAttributes(): Record<string, string | number | boolean | undefined>;
+    getChildren(): LightBurnBaseElement[];
     static readCommon(node: XmlJsonElement): {
         cutIndex?: number;
         locked?: boolean;
@@ -208,6 +227,7 @@ declare class ShapeRect extends ShapeBase {
     h?: number;
     cr?: number;
     constructor();
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
     static fromXmlJson(node: XmlJsonElement): ShapeRect;
 }
 
@@ -238,6 +258,8 @@ declare class ShapePath extends ShapeBase {
     private static templateRegistry;
     constructor(init?: ShapePathInit);
     static clearTemplateRegistry(): void;
+    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
+    getChildren(): LightBurnBaseElement[];
     static fromXmlJson(node: XmlJsonElement): ShapePath;
     /**
      * Parse encoded VertList string format

package/dist/index.js

@@ -45,21 +45,62 @@ var LightBurnBaseElement = class _LightBurnBaseElement {
   getChildren() {
     return [];
   }
-  getStringIndented() {
-    return this.getString().split("\n").map((line) => `  ${line}`).join("\n");
+  /**
+   * Get XML attributes for this element
+   * Subclasses should override this to provide their specific attributes
+   */
+  getXmlAttributes() {
+    return {};
   }
-  getString() {
+  /**
+   * Get the XML tag name for this element
+   * By default, uses the token, but can be overridden
+   */
+  getXmlTag() {
+    if (this.token.startsWith("Shape.")) {
+      return "Shape";
+    }
+    return this.token;
+  }
+  /**
+   * Convert this element to XML string
+   */
+  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 children = this.getChildren();
     if (children.length === 0) {
-      return `(${this.token})`;
+      return `${indentStr}<${tag}${attrStr}/>`;
     }
-    const lines = [`(${this.token}`];
-    for (const p of children) {
-      lines.push(p.getStringIndented());
+    const lines = [`${indentStr}<${tag}${attrStr}>`];
+    for (const child of children) {
+      lines.push(child.toXml(indent + 1));
     }
-    lines.push(")");
+    lines.push(`${indentStr}</${tag}>`);
     return lines.join("\n");
   }
+  getStringIndented() {
+    return this.getString().split("\n").map((line) => `  ${line}`).join("\n");
+  }
+  getString() {
+    if (this.token === "LightBurnProject") {
+      return `<?xml version="1.0" encoding="UTF-8"?>
+${this.toXml()}`;
+    }
+    return this.toXml();
+  }
   get [Symbol.toStringTag]() {
     return this.getString();
   }
@@ -216,6 +257,15 @@ var LightBurnProject = class _LightBurnProject extends LightBurnBaseElement {
   getChildren() {
     return this.children;
   }
+  getXmlAttributes() {
+    return {
+      AppVersion: this.appVersion,
+      FormatVersion: this.formatVersion,
+      MaterialHeight: this.materialHeight,
+      MirrorX: this.mirrorX,
+      MirrorY: this.mirrorY
+    };
+  }
 };
 LightBurnBaseElement.register("LightBurnProject", LightBurnProject);
 
@@ -405,6 +455,44 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
   set lineAngle(value) {
     this._lineAngle = value;
   }
+  getXmlAttributes() {
+    return {
+      type: this._type
+    };
+  }
+  getChildren() {
+    const children = [];
+    const props = [
+      "index",
+      "name",
+      "priority",
+      "minPower",
+      "maxPower",
+      "minPower2",
+      "maxPower2",
+      "speed",
+      "kerf",
+      "zOffset",
+      "enablePowerRamp",
+      "rampLength",
+      "numPasses",
+      "zPerPass",
+      "perforate",
+      "dotMode",
+      "scanOpt",
+      "interval",
+      "angle",
+      "overScanning",
+      "lineAngle"
+    ];
+    for (const prop of props) {
+      const value = this[`_${prop}`];
+      if (value !== void 0) {
+        children.push(new CutSettingPropertyElement(prop, value));
+      }
+    }
+    return children;
+  }
   static fromXmlJson(node) {
     const cs = new _CutSetting();
     if (node.$) {
@@ -438,6 +526,20 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
     return cs;
   }
 };
+var CutSettingPropertyElement = class extends LightBurnBaseElement {
+  propName;
+  propValue;
+  constructor(propName, propValue) {
+    super();
+    this.token = propName;
+    this.propName = propName;
+    this.propValue = propValue;
+  }
+  toXml(indent = 0) {
+    const indentStr = "    ".repeat(indent);
+    return `${indentStr}<${this.propName} Value="${this.propValue}"/>`;
+  }
+};
 LightBurnBaseElement.register("CutSetting", CutSetting);
 
 // lib/classes/elements/Notes.ts
@@ -536,6 +638,20 @@ var ShapeBase = class extends LightBurnBaseElement {
   cutIndex;
   locked;
   xform;
+  getShapeXmlAttributes() {
+    return {
+      CutIndex: this.cutIndex,
+      Locked: this.locked
+    };
+  }
+  getChildren() {
+    const children = [];
+    if (this.xform) {
+      const xformElement = new XFormElement(this.xform);
+      children.push(xformElement);
+    }
+    return children;
+  }
   static readCommon(node) {
     const common = {};
     if (node.$) {
@@ -559,6 +675,19 @@ var ShapeBase = class extends LightBurnBaseElement {
     return common;
   }
 };
+var XFormElement = class extends LightBurnBaseElement {
+  mat;
+  constructor(mat) {
+    super();
+    this.token = "XForm";
+    this.mat = mat;
+  }
+  toXml(indent = 0) {
+    const indentStr = "    ".repeat(indent);
+    const value = this.mat.join(" ");
+    return `${indentStr}<XForm>${value}</XForm>`;
+  }
+};
 
 // lib/classes/elements/shapes/ShapeEllipse.ts
 var ShapeEllipse = class _ShapeEllipse extends ShapeBase {
@@ -590,6 +719,15 @@ var ShapeRect = class _ShapeRect extends ShapeBase {
     super();
     this.token = "Shape.Rect";
   }
+  getXmlAttributes() {
+    return {
+      Type: "Rect",
+      ...this.getShapeXmlAttributes(),
+      W: this.w,
+      H: this.h,
+      Cr: this.cr
+    };
+  }
   static fromXmlJson(node) {
     const rect = new _ShapeRect();
     const common = ShapeBase.readCommon(node);
@@ -627,6 +765,22 @@ var ShapePath = class _ShapePath extends ShapeBase {
   static clearTemplateRegistry() {
     _ShapePath.templateRegistry.clear();
   }
+  getXmlAttributes() {
+    return {
+      Type: "Path",
+      ...this.getShapeXmlAttributes()
+    };
+  }
+  getChildren() {
+    const children = super.getChildren();
+    if (this.verts.length > 0) {
+      children.push(new VertListElement(this.verts));
+    }
+    if (this.prims.length > 0) {
+      children.push(new PrimListElement(this.prims, this.isClosed));
+    }
+    return children;
+  }
   static fromXmlJson(node) {
     const path = new _ShapePath();
     const common = ShapeBase.readCommon(node);
@@ -642,11 +796,16 @@ var ShapePath = class _ShapePath extends ShapeBase {
         const verts = Array.isArray(vertList.Vert) ? vertList.Vert : [vertList.Vert];
         for (const v of verts) {
           if (v.$) {
-            path.verts.push({
+            const vert = {
               x: num(v.$.x, 0),
               y: num(v.$.y, 0),
               c: num(v.$.c, void 0)
-            });
+            };
+            if (v.$.c0x !== void 0) vert.c0x = num(v.$.c0x, void 0);
+            if (v.$.c0y !== void 0) vert.c0y = num(v.$.c0y, void 0);
+            if (v.$.c1x !== void 0) vert.c1x = num(v.$.c1x, void 0);
+            if (v.$.c1y !== void 0) vert.c1y = num(v.$.c1y, void 0);
+            path.verts.push(vert);
           }
         }
       }
@@ -771,6 +930,60 @@ var ShapePath = class _ShapePath extends ShapeBase {
     return prims;
   }
 };
+var VertListElement = class extends LightBurnBaseElement {
+  verts;
+  constructor(verts) {
+    super();
+    this.token = "VertList";
+    this.verts = verts;
+  }
+  toXml(indent = 0) {
+    const indentStr = "    ".repeat(indent);
+    const innerIndent = "    ".repeat(indent + 1);
+    const lines = [`${indentStr}<VertList>`];
+    for (const vert of this.verts) {
+      let attrs = `x="${vert.x}" y="${vert.y}"`;
+      if (vert.c !== void 0) {
+        attrs += ` c="${vert.c}"`;
+      }
+      if (vert.c0x !== void 0) {
+        attrs += ` c0x="${vert.c0x}"`;
+      }
+      if (vert.c0y !== void 0) {
+        attrs += ` c0y="${vert.c0y}"`;
+      }
+      if (vert.c1x !== void 0) {
+        attrs += ` c1x="${vert.c1x}"`;
+      }
+      if (vert.c1y !== void 0) {
+        attrs += ` c1y="${vert.c1y}"`;
+      }
+      lines.push(`${innerIndent}<Vert ${attrs}/>`);
+    }
+    lines.push(`${indentStr}</VertList>`);
+    return lines.join("\n");
+  }
+};
+var PrimListElement = class extends LightBurnBaseElement {
+  prims;
+  isClosed;
+  constructor(prims, isClosed) {
+    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}"/>`);
+    }
+    lines.push(`${indentStr}</PrimList>`);
+    return lines.join("\n");
+  }
+};
 LightBurnBaseElement.register("Shape.Path", ShapePath);
 
 // lib/classes/elements/shapes/ShapeText.ts

package/package.json

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