@nmmty/lazycanvas 0.6.5 → 1.0.0-dev.10

package/dist/structures/helpers/Exporter.d.ts

@@ -1,19 +1,24 @@
 import { IOLazyCanvas, LazyCanvas } from "../LazyCanvas";
 import { AnyExport } from "../../types";
 import { Canvas, SKRSContext2D, SvgCanvas } from "@napi-rs/canvas";
+import { Scene } from "../../core";
 /**
- * Class responsible for exporting a LazyCanvas instance to various formats.
+ * Class responsible for exporting a LazyCanvas or Scene instance to various formats.
  */
 export declare class Exporter {
     /**
      * The LazyCanvas instance to be exported.
      */
-    canvas: LazyCanvas;
+    canvas?: LazyCanvas;
+    /**
+     * The Scene instance to be exported.
+     */
+    scene?: Scene;
     /**
      * Constructs a new Exporter instance.
-     * @param canvas {LazyCanvas} - The LazyCanvas instance to be exported.
+     * @param source {LazyCanvas | Scene} - The LazyCanvas or Scene instance to be exported.
      */
-    constructor(canvas: LazyCanvas);
+    constructor(source: LazyCanvas | Scene);
     /**
      * Saves a file to the filesystem.
      * @param {any} [buffer] - The data to be saved.
@@ -34,12 +39,16 @@ export declare class Exporter {
      * @param {Object} [opts] - Optional settings.
      * @param {string} [opts.name] - The name of the file (optional).
      * @param {boolean} [opts.saveAsFile] - Whether to save the export as a file (optional).
+     * @param {number} [opts.duration] - Duration of the animation in seconds (Scene only).
+     * @param {number} [opts.fps] - Frames per second for animation (default: 60, Scene only).
      * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The exported data.
      * @throws {LazyError} If the export type is not supported.
      */
     export(exportType: AnyExport, opts?: {
         name?: string;
         saveAsFile?: boolean;
+        duration?: number;
+        fps?: number;
     }): Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>;
     /**
      * Synchronously exports the canvas to the specified format.

package/dist/structures/helpers/Exporter.js

@@ -32,27 +32,33 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exporter = void 0;
 const types_1 = require("../../types");
-const LazyUtil_1 = require("../../utils/LazyUtil");
-const fs = __importStar(require("fs"));
-const utils_1 = require("../../utils/utils");
+const utils_1 = require("../../utils");
+const fs = __importStar(require("node:fs"));
 const _yaml = __importStar(require("js-yaml"));
+const APNGEncoder_1 = __importDefault(require("../../utils/APNGEncoder"));
+const core_1 = require("../../core");
 /**
- * Class responsible for exporting a LazyCanvas instance to various formats.
+ * Class responsible for exporting a LazyCanvas or Scene instance to various formats.
  */
 class Exporter {
-    /**
-     * The LazyCanvas instance to be exported.
-     */
-    canvas;
     /**
      * Constructs a new Exporter instance.
-     * @param canvas {LazyCanvas} - The LazyCanvas instance to be exported.
+     * @param source {LazyCanvas | Scene} - The LazyCanvas or Scene instance to be exported.
      */
-    constructor(canvas) {
-        this.canvas = canvas;
+    constructor(source) {
+        if (source instanceof core_1.Scene) {
+            this.scene = source;
+            this.canvas = source.lazyCanvas;
+        }
+        else {
+            this.canvas = source;
+        }
     }
     /**
      * Saves a file to the filesystem.
@@ -63,9 +69,9 @@ class Exporter {
      */
     async saveFile(buffer, extension, name) {
         if (!buffer)
-            throw new LazyUtil_1.LazyError('Buffer must be provided');
+            throw new utils_1.LazyError("Buffer must be provided");
         if (!extension)
-            throw new LazyUtil_1.LazyError('Extension must be provided');
+            throw new utils_1.LazyError("Extension must be provided");
         fs.writeFileSync(`${name === undefined ? (0, utils_1.generateRandomName)() : name}.${extension}`, buffer);
     }
     /**
@@ -86,12 +92,15 @@ class Exporter {
      * @param {Object} [opts] - Optional settings.
      * @param {string} [opts.name] - The name of the file (optional).
      * @param {boolean} [opts.saveAsFile] - Whether to save the export as a file (optional).
+     * @param {number} [opts.duration] - Duration of the animation in seconds (Scene only).
+     * @param {number} [opts.fps] - Frames per second for animation (default: 60, Scene only).
      * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The exported data.
      * @throws {LazyError} If the export type is not supported.
      */
     async export(exportType, opts) {
-        // beforeExport hook
-        this.canvas.manager.plugins.executeHook('beforeExport', this.canvas);
+        if (!this.canvas) {
+            throw new utils_1.LazyError("Canvas is not initialized");
+        }
         let result;
         switch (exportType) {
             case types_1.Export.CTX:
@@ -100,69 +109,94 @@ class Exporter {
                 break;
             case types_1.Export.SVG:
             case "svg":
-                result = await this.canvas.manager.render.render('svg');
+                result = await this.canvas.manager.render.render("svg");
                 if (opts?.saveAsFile) {
-                    await this.saveFile(result, 'svg', opts.name);
+                    await this.saveFile(result, "svg", opts.name);
                 }
                 break;
             case types_1.Export.BUFFER:
             case "buffer":
-                result = await this.canvas.manager.render.render('buffer');
-                if (opts?.saveAsFile) {
-                    await this.saveFile(result, 'png', opts.name);
+                if (this.scene) {
+                    result = await this.scene.renderFirstFrame().then((frame) => frame.toBuffer("image/png"));
+                }
+                else {
+                    result = (await this.canvas.manager.render.render("buffer"));
                 }
-                break;
-            case types_1.Export.GIF:
-            case "gif":
-                result = await this.canvas.manager.render.render('buffer');
                 if (opts?.saveAsFile) {
-                    await this.saveFile(result, 'gif', opts.name);
+                    await this.saveFile(result, "png", opts.name);
                 }
                 break;
             case types_1.Export.WEBP:
             case "webp":
-                result = await this.canvas.manager.render.render('buffer');
+                if (this.scene) {
+                    result = await this.scene
+                        .renderFirstFrame()
+                        .then((frame) => frame.toBuffer("image/webp"));
+                }
+                else {
+                    result = await this.canvas.manager.render.render("webp");
+                }
                 if (opts?.saveAsFile) {
-                    await this.saveFile(result, 'webp', opts.name);
+                    await this.saveFile(result, "webp", opts.name);
                 }
                 break;
-            case types_1.Export.JPEG:
-            case "jpeg":
-                result = await this.canvas.manager.render.render('buffer');
-                await this.saveFile(result, 'jpeg', opts?.name);
-                break;
             case types_1.Export.JPG:
             case "jpg":
-                const jpg = await this.canvas.manager.render.render('buffer');
-                await this.saveFile(jpg, 'jpg', opts?.name);
-                return jpg;
+                if (this.scene) {
+                    result = await this.scene
+                        .renderFirstFrame()
+                        .then((frame) => frame.toBuffer("image/jpeg"));
+                }
+                else {
+                    result = await this.canvas.manager.render.render("jpg");
+                }
+                await this.saveFile(result, "jpg", opts?.name);
+                return result;
             case types_1.Export.PNG:
             case "png":
-                const png = await this.canvas.manager.render.render('buffer');
-                await this.saveFile(png, 'png', opts?.name);
-                return png;
+                if (this.scene) {
+                    result = await this.scene.renderFirstFrame().then((frame) => frame.toBuffer("image/png"));
+                }
+                else {
+                    result = await this.canvas.manager.render.render("png");
+                }
+                await this.saveFile(result, "png", opts?.name);
+                return result;
+            case types_1.Export.APNG:
+            case "apng":
+                if (!this.scene) {
+                    throw new utils_1.LazyError("APNG export requires a Scene instance. Use: new Exporter(scene)");
+                }
+                const duration = opts?.duration ?? 0;
+                const timeNow = Date.now();
+                const fps = opts?.fps ?? 60;
+                const frameData = await this.scene.renderAnimationData(timeNow, timeNow + duration, fps);
+                const encoder = new APNGEncoder_1.default(this.scene.width, this.scene.height, fps).addFrames(...frameData);
+                const buffer = encoder.encode();
+                if (opts?.saveAsFile !== false) {
+                    fs.writeFileSync(`${opts?.name ?? "animation"}.png`, buffer);
+                }
+                return buffer;
             case types_1.Export.JSON:
             case "json":
                 const json = this.syncExport(exportType);
                 if (opts?.saveAsFile) {
-                    await this.saveFile(JSON.stringify(json), 'json', opts.name);
+                    await this.saveFile(JSON.stringify(json), "json", opts.name);
                 }
                 return JSON.stringify(json);
             case types_1.Export.CANVAS:
             case "canvas":
-                return await this.canvas.manager.render.render(exportType);
+                return (await this.canvas.manager.render.render(exportType));
             case types_1.Export.YAML:
             case "yaml":
                 const yaml = _yaml.dump(this.syncExport(types_1.Export.JSON));
                 if (opts?.saveAsFile) {
-                    await this.saveFile(yaml, 'yaml', opts.name);
+                    await this.saveFile(yaml, "yaml", opts.name);
                 }
                 return yaml;
             default:
-                throw new LazyUtil_1.LazyError(`Export type ${exportType} is not supported`);
+                throw new utils_1.LazyError(`Export type ${exportType} is not supported`);
         }
-        // afterExport hook
-        this.canvas.manager.plugins.executeHook('afterExport', this.canvas, result);
         return result;
     }
     /**
@@ -171,13 +205,15 @@ class Exporter {
      * @returns {IOLazyCanvas | void} The exported data or void if the export type is unsupported.
      */
     syncExport(exportType) {
+        if (!this.canvas) {
+            throw new utils_1.LazyError("Canvas is not initialized");
+        }
         switch (exportType) {
             case types_1.Export.JSON:
             case "json":
                 return {
                     options: this.canvas.options,
-                    animation: this.canvas.manager.animation.options,
-                    layers: this.exportLayers(this.canvas.manager.layers)
+                    layers: this.exportLayers(this.canvas.manager.layers),
                 };
         }
     }

package/dist/structures/helpers/Font.js

@@ -6,22 +6,6 @@ const types_1 = require("../../types");
  * Class representing a font with properties such as family, weight, path, and base64.
  */
 class Font {
-    /**
-     * The font family.
-     */
-    family;
-    /**
-     * The weight of the font.
-     */
-    weight;
-    /**
-     * The file path of the font (optional).
-     */
-    path;
-    /**
-     * The base64 representation of the font (optional).
-     */
-    base64;
     /**
      * Constructs a new Font instance with default values.
      */
@@ -86,7 +70,7 @@ class Font {
             family: this.family,
             weight: this.weight,
             path: this.path,
-            base64: this.base64
+            base64: this.base64,
         };
     }
 }

package/dist/structures/helpers/Gradient.js

@@ -2,38 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gradient = void 0;
 const types_1 = require("../../types");
-const LazyUtil_1 = require("../../utils/LazyUtil");
-const utils_1 = require("../../utils/utils");
+const utils_1 = require("../../utils");
 /**
  * Class representing a gradient with properties and methods to manipulate it.
  */
 class Gradient {
-    /**
-     * The type of fill, which is always `Gradient`.
-     */
-    fillType = types_1.FillType.Gradient;
-    /**
-     * The type of gradient (e.g., linear, radial, conic).
-     */
-    type;
-    /**
-     * The points defining the gradient.
-     */
-    points;
-    /**
-     * The color stops for the gradient.
-     */
-    stops;
-    /**
-     * The angle of the gradient (optional, used for linear gradients).
-     */
-    angle;
     /**
      * Constructs a new Gradient instance.
      * @param {Object} [opts] - Optional properties for the gradient.
      * @param {IGradient} [opts.props] - The gradient properties.
      */
     constructor(opts) {
+        /**
+         * The type of fill, which is always `Gradient`.
+         */
+        this.fillType = types_1.FillType.Gradient;
         this.type = opts?.props?.type || types_1.GradientType.Linear;
         this.points = opts?.props?.points || [];
         this.stops = opts?.props?.stops || [];
@@ -115,33 +98,36 @@ class Gradient {
         let gradientData = this.toJSON();
         let gradient;
         if (opts.debug)
-            LazyUtil_1.LazyLog.log('none', `Gradient:`, gradientData);
+            utils_1.LazyLog.log("none", `Gradient:`, gradientData);
         const parse = (0, utils_1.parser)(ctx, ctx.canvas, opts.manager);
         const { x0, y0, x1, y1 } = parse.parseBatch({
             x0: { v: gradientData.points[0]?.x || 0 },
-            y0: { v: gradientData.points[0]?.y || 0, options: LazyUtil_1.defaultArg.vl(true) },
+            y0: { v: gradientData.points[0]?.y || 0, options: utils_1.defaultArg.vl(true) },
             x1: { v: gradientData.points[1]?.x || 0 },
-            y1: { v: gradientData.points[1]?.y || 0, options: LazyUtil_1.defaultArg.vl(true) }
+            y1: { v: gradientData.points[1]?.y || 0, options: utils_1.defaultArg.vl(true) },
         });
         if (opts.debug)
-            LazyUtil_1.LazyLog.log('none', `Gradient points:`, { x0, y0, x1, y1 });
+            utils_1.LazyLog.log("none", `Gradient points:`, { x0, y0, x1, y1 });
         switch (gradientData.type) {
             case types_1.GradientType.Linear:
             case "linear":
-                if (gradientData.type === "linear" && (gradientData.angle || gradientData.angle === 0) && opts.layer && gradientData.points.length < 2) {
+                if (gradientData.type === "linear" &&
+                    (gradientData.angle || gradientData.angle === 0) &&
+                    opts.layer &&
+                    gradientData.points.length < 2) {
                     const { width, height, x, y, align } = opts.layer;
-                    const cx = this.getPosition(x, width, align, 'x');
-                    const cy = this.getPosition(y, height, align, 'y');
+                    const cx = this.getPosition(x, width, align, "x");
+                    const cy = this.getPosition(y, height, align, "y");
                     if (opts.debug)
-                        LazyUtil_1.LazyLog.log('none', `Center for angle calculation:`, { cx, cy });
+                        utils_1.LazyLog.log("none", `Center for angle calculation:`, { cx, cy });
                     const [p1, p2] = this.getLinearGradientPoints(cx, cy, width, height, gradientData.angle);
                     if (opts.debug)
-                        LazyUtil_1.LazyLog.log('none', `Linear Gradient Points from angle:`, { p1, p2 });
+                        utils_1.LazyLog.log("none", `Linear Gradient Points from angle:`, { p1, p2 });
                     gradient = ctx.createLinearGradient(p1.x, p1.y, p2.x, p2.y);
                 }
                 else {
                     if (opts.debug)
-                        LazyUtil_1.LazyLog.log('none', `Linear Gradient created from points.`);
+                        utils_1.LazyLog.log("none", `Linear Gradient created from points.`);
                     gradient = ctx.createLinearGradient(x0, y0, x1 || x0, y1 || y0);
                 }
                 break;
@@ -156,8 +142,8 @@ class Gradient {
             default:
                 if ((gradientData.angle || gradientData.angle === 0) && opts.layer) {
                     const { width, height, x, y, align } = opts.layer;
-                    const cx = this.getPosition(x, width, align, 'x');
-                    const cy = this.getPosition(y, height, align, 'y');
+                    const cx = this.getPosition(x, width, align, "x");
+                    const cy = this.getPosition(y, height, align, "y");
                     const [p1, p2] = this.getLinearGradientPoints(cx, cy, width, height, gradientData.angle);
                     gradient = ctx.createLinearGradient(p1.x, p1.y, p2.x, p2.y);
                 }
@@ -167,7 +153,7 @@ class Gradient {
                 break;
         }
         for (let stop of gradientData.stops) {
-            gradient.addColorStop(stop.offset, stop.color);
+            gradient.addColorStop(stop.offset, (0, utils_1.parseFillStyle)(ctx, stop.color, opts));
         }
         return gradient;
     }
@@ -181,7 +167,7 @@ class Gradient {
             type: this.type,
             points: this.points,
             stops: this.stops,
-            angle: this.angle
+            angle: this.angle,
         };
     }
     getLinearGradientPoints(cx, cy, w, h, angleInDegrees) {
@@ -198,43 +184,43 @@ class Gradient {
         const y2r = cy + (x2 - cx) * sin + (y2 - cy) * cos;
         return [
             { x: x1r, y: y1r },
-            { x: x2r, y: y2r }
+            { x: x2r, y: y2r },
         ];
     }
-    getPosition(pos, side, align, type = 'x') {
+    getPosition(pos, side, align, type = "x") {
         switch (align) {
             case types_1.Centring.StartTop:
             case "start-top":
-                return type === 'x' ? pos + (side / 2) : pos + (side / 2);
+                return type === "x" ? pos + side / 2 : pos + side / 2;
             case types_1.Centring.Start:
             case "start":
-                return type === 'x' ? pos + (side / 2) : pos;
+                return type === "x" ? pos + side / 2 : pos;
             case types_1.Centring.StartBottom:
             case "start-bottom":
-                return type === 'x' ? pos + (side / 2) : pos - (side / 2);
+                return type === "x" ? pos + side / 2 : pos - side / 2;
             case types_1.Centring.CenterTop:
             case "center-top":
-                return type === 'x' ? pos : pos - (side / 2);
+                return type === "x" ? pos : pos - side / 2;
             case types_1.Centring.Center:
             case "center":
-                return type === 'x' ? pos : pos;
+                return type === "x" ? pos : pos;
             case types_1.Centring.CenterBottom:
             case "center-bottom":
-                return type === 'x' ? pos : pos - (side / 2);
+                return type === "x" ? pos : pos - side / 2;
             case types_1.Centring.EndTop:
             case "end-top":
-                return type === 'x' ? pos - (side / 2) : pos + (side / 2);
+                return type === "x" ? pos - side / 2 : pos + side / 2;
             case types_1.Centring.End:
             case "end":
-                return type === 'x' ? pos - (side / 2) : pos;
+                return type === "x" ? pos - side / 2 : pos;
             case types_1.Centring.EndBottom:
             case "end-bottom":
-                return type === 'x' ? pos - (side / 2) : pos - (side / 2);
+                return type === "x" ? pos - side / 2 : pos - side / 2;
             case types_1.Centring.None:
             case "none":
-                return type === 'x' ? pos + (side / 2) : pos + (side / 2);
+                return type === "x" ? pos + side / 2 : pos + side / 2;
             default:
-                throw new LazyUtil_1.LazyError(`Invalid centring type: ${align}`);
+                throw new utils_1.LazyError(`Invalid centring type: ${align}`);
         }
     }
 }

package/dist/structures/helpers/Link.js

@@ -6,25 +6,13 @@ const types_1 = require("../../types");
  * Class representing a link between layers with properties and methods to manipulate it.
  */
 class Link {
-    /**
-     * The source layers ID.
-     */
-    source;
-    /**
-     * The type of the link (e.g., width, height, etc.).
-     */
-    type;
-    /**
-     * The additional spacing applied to the link.
-     */
-    additionalSpacing;
     /**
      * Constructs a new Link instance.
      * @param {Object} [opts] - Optional properties for the link.
      * @param {ILink} [opts.props] - The link properties.
      */
     constructor(opts) {
-        this.source = opts?.props?.source || '';
+        this.source = opts?.props?.source || "";
         this.type = opts?.props?.type || types_1.LinkType.Width;
         this.additionalSpacing = opts?.props?.additionalSpacing || 0;
     }
@@ -63,7 +51,7 @@ class Link {
         return {
             source: this.source,
             type: this.type,
-            additionalSpacing: this.additionalSpacing
+            additionalSpacing: this.additionalSpacing,
         };
     }
 }

package/dist/structures/helpers/Pattern.js

@@ -5,31 +5,23 @@ const types_1 = require("../../types");
 const LazyCanvas_1 = require("../LazyCanvas");
 const canvas_1 = require("@napi-rs/canvas");
 const Exporter_1 = require("./Exporter");
-const LazyUtil_1 = require("../../utils/LazyUtil");
+const utils_1 = require("../../utils");
 /**
  * Class representing a pattern with properties and methods to manipulate it.
  */
 class Pattern {
-    /**
-     * The type of fill, which is always `Pattern`.
-     */
-    fillType = types_1.FillType.Pattern;
-    /**
-     * The type of the pattern (e.g., repeat, no-repeat, etc.).
-     */
-    type;
-    /**
-     * The source of the pattern, which can be a string (URL or path) or a LazyCanvas instance.
-     */
-    src;
     /**
      * Constructs a new Pattern instance.
      * @param {Object} [opts] - Optional properties for the pattern.
      * @param {IPattern} [opts.props] - The pattern properties.
      */
     constructor(opts) {
+        /**
+         * The type of fill, which is always `Pattern`.
+         */
+        this.fillType = types_1.FillType.Pattern;
         this.type = opts?.props?.type || types_1.PatternType.Repeat;
-        this.src = opts?.props?.src || '';
+        this.src = opts?.props?.src || "";
     }
     /**
      * Sets the type of the pattern.
@@ -56,9 +48,9 @@ class Pattern {
      */
     async draw(ctx) {
         if (!this.src)
-            throw new LazyUtil_1.LazyError('Pattern source is not set');
+            throw new utils_1.LazyError("Pattern source is not set");
         if (this.src instanceof LazyCanvas_1.LazyCanvas) {
-            return ctx.createPattern((await this.src.manager.render.render('canvas')), this.type);
+            return ctx.createPattern((await this.src.manager.render.render("canvas")), this.type);
         }
         return ctx.createPattern(await (0, canvas_1.loadImage)(this.src), this.type);
     }
@@ -70,12 +62,12 @@ class Pattern {
         let src = this.src;
         if (this.src instanceof LazyCanvas_1.LazyCanvas) {
             // @ts-ignore
-            src = new Exporter_1.Exporter(this.src).syncExport('json');
+            src = new Exporter_1.Exporter(this.src).syncExport("json");
         }
         return {
             fillType: this.fillType,
             type: this.type,
-            src: src
+            src: src,
         };
     }
 }

package/dist/structures/helpers/index.d.ts

@@ -1,7 +1,7 @@
-export * from './Exporter';
-export * from './Font';
-export * from './Gradient';
-export * from './Link';
-export * from './Pattern';
-export * from './readers/JSONReader';
-export * from './readers/YAMLReader';
+export * from "./Exporter";
+export * from "./Font";
+export * from "./Gradient";
+export * from "./Link";
+export * from "./Pattern";
+export * from "./readers/JSONReader";
+export * from "./readers/YAMLReader";

package/dist/structures/helpers/readers/JSONReader.d.ts

@@ -27,17 +27,17 @@ export declare class JSONReader {
     }): LazyCanvas;
     /**
      * Parses an array of JSON layers into an array of AnyLayer or Group instances.
-     * @param {Array<JSONLayer | Group>} [data] - The array of JSON layers to parse.
+     * @param {Array<JSONLayer | Div>} [data] - The array of JSON layers to parse.
      * @param {Object} [opts] - Optional settings.
      * @param {boolean} [opts.debug] - Whether to enable debug logging.
-     * @returns {Array<AnyLayer | Group>} The parsed layers.
+     * @returns {Array<AnyLayer | Div>} The parsed layers.
      */
     private static layersParse;
     /**
      * Parses a single JSON layer into an AnyLayer or Group instance.
-     * @param {JSONLayer | IGroup | Group} [layer] - The JSON layer to parse.
+     * @param {JSONLayer | IDiv | Div} [layer] - The JSON layer to parse.
      * @param {IBaseLayerMisc} [misc] - Miscellaneous options for the layer.
-     * @returns {AnyLayer | Group} The parsed layer.
+     * @returns {AnyLayer | Div} The parsed layer.
      */
     private static layerParse;
     /**