lbrnts 0.0.19 → 0.0.22

package/README.md

@@ -20,6 +20,32 @@ const project = LightBurnProject.parse(fs.readFileSync("project.lbrn2", "utf8"))
 console.log(project.children)
 ```
 
+### Offsetting Project Content
+
+```tsx
+import {
+  applyOffsetToLbrn,
+  LightBurnBaseElement,
+  LightBurnProject,
+} from "lbrnts"
+
+const source = fs.readFileSync("project.lbrn2", "utf8")
+const project = LightBurnBaseElement.parse(source)
+
+if (project instanceof LightBurnProject) {
+  applyOffsetToLbrn({
+    lbrnProject: project,
+    xOffset: 10,
+    yOffset: -5,
+  })
+
+  const shifted = project.getString()
+}
+```
+
+This mutates the parsed project by offsetting top-level shape transforms. Call
+`getString()` when you need LightBurn XML output.
+
 ### Creating Projects from Scratch
 
 You can programmatically create LightBurn projects by constructing the project and its elements. Below is a table of all constructible classes with links to their documentation:
@@ -132,6 +158,8 @@ new CutSetting(init?: {
   angle?: number              // Scan angle
   overScanning?: number       // Over-scanning distance
   lineAngle?: number          // Line angle for fill
+  wobbleEnable?: boolean      // Enable wobble for scan fills
+  anglePerPass?: number       // Hatch angle increment per pass
 })
 ```
 

package/dist/index.d.ts

@@ -92,6 +92,8 @@ interface CutSettingInit {
     overScanning?: number;
     lineAngle?: number;
     crossHatch?: boolean;
+    wobbleEnable?: boolean;
+    anglePerPass?: number;
     frequency?: number;
     qPulseWidth?: number;
 }
@@ -119,6 +121,8 @@ declare class CutSetting extends LightBurnBaseElement {
     private _overScanning?;
     private _lineAngle?;
     private _crossHatch?;
+    private _wobbleEnable?;
+    private _anglePerPass?;
     private _frequency?;
     private _qPulseWidth?;
     constructor(init?: CutSettingInit);
@@ -168,6 +172,10 @@ declare class CutSetting extends LightBurnBaseElement {
     set lineAngle(value: number | undefined);
     get crossHatch(): boolean | undefined;
     set crossHatch(value: boolean | undefined);
+    get wobbleEnable(): boolean | undefined;
+    set wobbleEnable(value: boolean | undefined);
+    get anglePerPass(): number | undefined;
+    set anglePerPass(value: number | undefined);
     get frequency(): number | undefined;
     set frequency(value: number | undefined);
     get qPulseWidth(): number | undefined;
@@ -373,6 +381,22 @@ interface GenerateSvgOptions {
 
 declare function generateLightBurnSvg(root: LightBurnBaseElement | LightBurnBaseElement[], options?: GenerateSvgOptions): string;
 
+interface SplitLightBurnProjectFile {
+    fileName: string;
+    content: string;
+    cutIndex: number;
+    cutSettingName: string;
+    shapeCount: number;
+}
+declare function splitLightBurnProjectByCutSetting(input: string | LightBurnProject, originalFileName?: string): SplitLightBurnProjectFile[];
+
+interface ApplyOffsetToLbrnParams {
+    lbrnProject: LightBurnProject;
+    xOffset: number;
+    yOffset: number;
+}
+declare function applyOffsetToLbrn(params: ApplyOffsetToLbrnParams): LightBurnProject;
+
 declare const parseXml: (xml: string) => XmlJson;
 
-export { LightBurnBaseElement as BaseLightBurnElement, CutSetting, type CutSettingInit, type GenerateSvgOptions, LightBurnBaseElement, LightBurnProject, type LightBurnProjectInit, type Mat, Notes, type Prim, ShapeBase, ShapeBitmap, ShapeEllipse, ShapeGroup, ShapePath, type ShapePathInit, ShapeRect, ShapeText, Thumbnail, UIPrefs, VariableText, type Vert, generateLightBurnSvg, parseXml };
+export { type ApplyOffsetToLbrnParams, LightBurnBaseElement as BaseLightBurnElement, CutSetting, type CutSettingInit, type GenerateSvgOptions, LightBurnBaseElement, LightBurnProject, type LightBurnProjectInit, type Mat, Notes, type Prim, ShapeBase, ShapeBitmap, ShapeEllipse, ShapeGroup, ShapePath, type ShapePathInit, ShapeRect, ShapeText, type SplitLightBurnProjectFile, Thumbnail, UIPrefs, VariableText, type Vert, applyOffsetToLbrn, generateLightBurnSvg, parseXml, splitLightBurnProjectByCutSetting };

package/dist/index.js

@@ -294,6 +294,8 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
   _overScanning;
   _lineAngle;
   _crossHatch;
+  _wobbleEnable;
+  _anglePerPass;
   _frequency;
   _qPulseWidth;
   constructor(init) {
@@ -325,6 +327,10 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
         this._overScanning = init.overScanning;
       if (init.lineAngle !== void 0) this._lineAngle = init.lineAngle;
       if (init.crossHatch !== void 0) this._crossHatch = init.crossHatch;
+      if (init.wobbleEnable !== void 0)
+        this._wobbleEnable = init.wobbleEnable;
+      if (init.anglePerPass !== void 0)
+        this._anglePerPass = init.anglePerPass;
       if (init.frequency !== void 0) this._frequency = init.frequency;
       if (init.qPulseWidth !== void 0) this._qPulseWidth = init.qPulseWidth;
     }
@@ -467,6 +473,18 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
   set crossHatch(value) {
     this._crossHatch = value;
   }
+  get wobbleEnable() {
+    return this._wobbleEnable;
+  }
+  set wobbleEnable(value) {
+    this._wobbleEnable = value;
+  }
+  get anglePerPass() {
+    return this._anglePerPass;
+  }
+  set anglePerPass(value) {
+    this._anglePerPass = value;
+  }
   get frequency() {
     return this._frequency;
   }
@@ -509,6 +527,8 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
       "overScanning",
       "lineAngle",
       "crossHatch",
+      "wobbleEnable",
+      "anglePerPass",
       "frequency",
       "qPulseWidth"
     ];
@@ -551,6 +571,8 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
     cs.overScanning = num(getChildValue("overScanning"), void 0);
     cs.lineAngle = num(getChildValue("lineAngle"), void 0);
     cs.crossHatch = boolish(getChildValue("crossHatch"), void 0);
+    cs.wobbleEnable = boolish(getChildValue("wobbleEnable"), void 0);
+    cs.anglePerPass = num(getChildValue("anglePerPass"), void 0);
     cs.frequency = num(getChildValue("frequency"), void 0);
     cs.qPulseWidth = num(getChildValue("QPulseWidth"), void 0);
     return cs;
@@ -566,7 +588,7 @@ var CutSettingPropertyElement = class extends LightBurnBaseElement {
     this.propValue = propValue;
   }
   formatValue(value) {
-    if (this.propName === "crossHatch" && typeof value === "boolean") {
+    if ((this.propName === "crossHatch" || this.propName === "wobbleEnable") && typeof value === "boolean") {
       return value ? "1" : "0";
     }
     if (typeof value === "number") {
@@ -1948,6 +1970,147 @@ function generateLightBurnSvg(root, options) {
   const svgTree = assembleSvg(nodes, layout, []);
   return stringify(svgTree);
 }
+
+// lib/split-by-cut-setting.ts
+function parseProject(input) {
+  if (input instanceof LightBurnProject) return input;
+  const parsed = LightBurnBaseElement.parse(input);
+  if (!(parsed instanceof LightBurnProject)) {
+    throw new Error("Expected a LightBurnProject XML document");
+  }
+  return parsed;
+}
+function fileBaseName(name, cutIndex) {
+  return name.trim().toLowerCase().replace(/[<>:"/\\|?*\x00-\x1F]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || `cut-index-${cutIndex}`;
+}
+function uniqueFileName(baseName, usedFileNames) {
+  let fileName = `${baseName}.lbrn2`;
+  let suffix = 2;
+  while (usedFileNames.has(fileName)) {
+    fileName = `${baseName}-${suffix}.lbrn2`;
+    suffix += 1;
+  }
+  usedFileNames.add(fileName);
+  return fileName;
+}
+function folderNameForFile(fileName) {
+  if (!fileName) return void 0;
+  const baseName = fileName.split(/[\\/]/).pop() ?? fileName;
+  return fileBaseName(baseName.replace(/\.lbrn2?$/i, ""), 0);
+}
+function cloneGroup(group, children) {
+  const clone = Object.assign(
+    Object.create(Object.getPrototypeOf(group)),
+    group
+  );
+  clone.children = children;
+  return clone;
+}
+function countShapes(element) {
+  if (element instanceof ShapeGroup) {
+    return element.children.reduce((sum, child) => sum + countShapes(child), 0);
+  }
+  return element instanceof ShapeBase ? 1 : 0;
+}
+function filterShapeForCutIndex(element, cutIndex) {
+  if (element instanceof ShapeGroup) {
+    if (element.cutIndex === cutIndex) {
+      return {
+        shape: cloneGroup(element, [...element.children]),
+        count: countShapes(element)
+      };
+    }
+    const children = [];
+    let count = 0;
+    for (const child of element.children) {
+      const result = filterShapeForCutIndex(child, cutIndex);
+      if (result.shape) children.push(result.shape);
+      count += result.count;
+    }
+    return children.length > 0 ? { shape: cloneGroup(element, children), count } : { count };
+  }
+  if (element instanceof ShapeBase && element.cutIndex === cutIndex) {
+    return { shape: element, count: 1 };
+  }
+  return { count: 0 };
+}
+function projectForCutSetting(project, cutSetting) {
+  const children = [];
+  const cutIndex = cutSetting.index;
+  let shapeCount = 0;
+  for (const child of project.children) {
+    if (child instanceof CutSetting) {
+      if (child === cutSetting) children.push(child);
+      continue;
+    }
+    if (child instanceof ShapeBase) {
+      const result = filterShapeForCutIndex(child, cutIndex);
+      if (result.shape) children.push(result.shape);
+      shapeCount += result.count;
+      continue;
+    }
+    children.push(child);
+  }
+  return {
+    project: new LightBurnProject({
+      appVersion: project.appVersion,
+      formatVersion: project.formatVersion,
+      materialHeight: project.materialHeight,
+      mirrorX: project.mirrorX,
+      mirrorY: project.mirrorY,
+      children
+    }),
+    shapeCount
+  };
+}
+function splitLightBurnProjectByCutSetting(input, originalFileName) {
+  const project = parseProject(input);
+  const folderName = folderNameForFile(originalFileName);
+  const usedFileNames = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const cutSetting of project.children) {
+    if (!(cutSetting instanceof CutSetting) || cutSetting.index === void 0) {
+      continue;
+    }
+    const cutIndex = cutSetting.index;
+    const cutSettingName = cutSetting.name ?? `CutIndex ${cutIndex}`;
+    const split = projectForCutSetting(project, cutSetting);
+    const fileName = uniqueFileName(
+      fileBaseName(cutSettingName, cutIndex),
+      usedFileNames
+    );
+    files.push({
+      fileName: folderName ? `${folderName}/${fileName}` : fileName,
+      content: split.project.getString(),
+      cutIndex,
+      cutSettingName,
+      shapeCount: split.shapeCount
+    });
+  }
+  return files;
+}
+
+// lib/apply-offset.ts
+function assertFiniteOffset(name, value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number`);
+  }
+}
+function applyOffsetToShape(shape, xOffset, yOffset) {
+  const [a, b, c, d, tx, ty] = shape.xform;
+  shape.xform = [a, b, c, d, tx + xOffset, ty + yOffset];
+}
+function applyOffsetToLbrn(params) {
+  const { lbrnProject, xOffset, yOffset } = params;
+  assertFiniteOffset("xOffset", xOffset);
+  assertFiniteOffset("yOffset", yOffset);
+  for (const child of lbrnProject.children) {
+    if (child instanceof ShapeBase) {
+      applyOffsetToShape(child, xOffset, yOffset);
+    }
+  }
+  return lbrnProject;
+}
 export {
   LightBurnBaseElement as BaseLightBurnElement,
   CutSetting,
@@ -1964,6 +2127,8 @@ export {
   Thumbnail,
   UIPrefs,
   VariableText,
+  applyOffsetToLbrn,
   generateLightBurnSvg,
-  parseXml
+  parseXml,
+  splitLightBurnProjectByCutSetting
 };

package/package.json

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