@nmmty/lazycanvas 0.3.6 → 0.5.0

package/dist/structures/managers/LayersManager.d.ts

@@ -1,74 +1,126 @@
 import { AnyLayer } from "../../types";
-import { ILayersManager } from "../../types";
-import { Group } from "../components/Group";
+import { Group } from "../components";
+/**
+ * Interface representing the LayersManager.
+ */
+export interface ILayersManager {
+    /**
+     * A map storing layers or groups with their IDs as keys.
+     */
+    map: Map<string, AnyLayer | Group>;
+    /**
+     * Whether debugging is enabled.
+     */
+    debug: boolean;
+}
+/**
+ * Class representing a manager for handling layers and groups.
+ */
 export declare class LayersManager implements ILayersManager {
+    /**
+     * A map storing layers or groups with their IDs as keys.
+     */
     map: Map<string, AnyLayer | Group>;
+    /**
+     * Whether debugging is enabled.
+     */
     debug: boolean;
-    constructor(debug?: boolean);
     /**
-     * Add a layer to the map
-     * @param layers {AnyLayer[]} - The `layer` or `group` to add to the map
+     * Constructs a new LayersManager instance.
+     * @param opts {Object} - Optional settings for the LayersManager.
+     * @param opts.debug {boolean} - Whether debugging is enabled.
+     */
+    constructor(opts?: {
+        debug?: boolean;
+    });
+    /**
+     * Adds layers or groups to the map.
+     * @param layers {Array<AnyLayer | Group>} - The layers or groups to add to the map.
+     * @returns {this} The current instance for chaining.
+     * @throws {LazyError} If a layer with the same ID already exists.
      */
-    add(...layers: AnyLayer[]): this;
+    add(...layers: Array<AnyLayer | Group>): this;
     /**
-     * Remove a layer from the map
-     * @param ids {string[]} - The `id` of the layer or group to remove
+     * Removes layers or groups from the map by their IDs.
+     * @param ids {string[]} - The IDs of the layers or groups to remove.
+     * @returns {this} The current instance for chaining.
      */
     remove(...ids: string[]): this;
     /**
-     * Clear all layers from the map
+     * Clears all layers and groups from the map.
+     * @returns {this} The current instance for chaining.
      */
     clear(): this;
     /**
-     * Get a layer from the map
-     * @param id {string} - The `id` of the layer or group to get
-     * @param cross {boolean} - Whether to search in groups or not
+     * Retrieves a layer or group from the map by its ID.
+     * @param id {string} - The ID of the layer or group to retrieve.
+     * @param cross {boolean} - Whether to search within groups for the ID.
+     * @returns {AnyLayer | Group | undefined} The retrieved layer or group, or undefined if not found.
      */
-    get(id: string, cross?: boolean): AnyLayer | undefined;
+    get(id: string, cross?: boolean): AnyLayer | Group | undefined;
     /**
-     * Check if a layer exists in the map
-     * @param id {string} - The `id` of the layer or group to check
+     * Checks if a layer or group exists in the map by its ID.
+     * @param id {string} - The ID of the layer or group to check.
+     * @returns {boolean} True if the layer or group exists, false otherwise.
      */
     has(id: string): boolean;
     /**
-     * Get the size of the map
+     * Retrieves the number of layers and groups in the map.
+     * @returns {number} The size of the map.
      */
     size(): number;
     /**
-     * Get the values of the map
+     * Retrieves the values (layers and groups) from the map.
+     * @returns {IterableIterator<AnyLayer | Group>} An iterator for the map values.
      */
-    values(): IterableIterator<AnyLayer>;
+    values(): IterableIterator<AnyLayer | Group>;
     /**
-     * Get the keys of the map
+     * Retrieves the keys (IDs) from the map.
+     * @returns {IterableIterator<string>} An iterator for the map keys.
      */
     keys(): IterableIterator<string>;
     /**
-     * Get the entries of the map
+     * Retrieves the entries (key-value pairs) from the map.
+     * @returns {IterableIterator<[string, AnyLayer | Group]>} An iterator for the map entries.
      */
-    entries(): IterableIterator<[string, AnyLayer]>;
+    entries(): IterableIterator<[string, AnyLayer | Group]>;
     /**
-     * For each layer in the map
-     * @param callbackfn {Function} - The `callback` function to execute
+     * Executes a callback function for each layer or group in the map.
+     * @param callbackfn {Function} - The callback function to execute.
+     * @returns {this} The current instance for chaining.
      */
-    forEach(callbackfn: (value: AnyLayer, key: string, map: Map<string, AnyLayer>) => void): this;
+    forEach(callbackfn: (value: AnyLayer | Group, key: string, map: Map<string, AnyLayer | Group>) => void): this;
     /**
-     * Convert the map to a JSON object
+     * Converts the map to a JSON object.
+     * @returns {object} The JSON representation of the map.
      */
     toJSON(): object;
     /**
-     * Convert a JSON object to the map
-     * @param json {object} - The `json` object to convert
+     * Populates the map from a JSON object.
+     * @param json {object} - The JSON object to populate the map from.
+     * @returns {this} The current instance for chaining.
      */
     fromJSON(json: object): this;
     /**
-     * Convert the map to an array
+     * Converts the map to an array of layers and groups.
+     * @returns {Array<AnyLayer | Group>} An array of layers and groups.
      */
-    toArray(): Array<AnyLayer>;
+    toArray(): Array<AnyLayer | Group>;
     /**
-     * Convert an array to the map
-     * @param array {Array<AnyLayer>} - The `array` to convert
+     * Populates the map from an array of layers and groups.
+     * @param array {Array<AnyLayer | Group>} - The array of layers and groups to populate the map from.
+     * @returns {this} The current instance for chaining.
+     */
+    fromArray(array: Array<AnyLayer | Group>): this;
+    /**
+     * Sorts the layers and groups in the map by their zIndex property.
+     * @returns {void}
      */
-    fromArray(array: Array<AnyLayer>): this;
     sort(): void;
+    /**
+     * Searches for a layer or group by its ID, including within groups.
+     * @param id {string} - The ID of the layer or group to search for.
+     * @returns {AnyLayer | Group | undefined} The found layer or group, or undefined if not found.
+     */
     private crossSearch;
 }

package/dist/structures/managers/LayersManager.js

@@ -1,18 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayersManager = void 0;
-const Group_1 = require("../components/Group");
+const components_1 = require("../components");
 const LazyUtil_1 = require("../../utils/LazyUtil");
+/**
+ * Class representing a manager for handling layers and groups.
+ */
 class LayersManager {
+    /**
+     * A map storing layers or groups with their IDs as keys.
+     */
     map;
+    /**
+     * Whether debugging is enabled.
+     */
     debug;
-    constructor(debug = false) {
+    /**
+     * Constructs a new LayersManager instance.
+     * @param opts {Object} - Optional settings for the LayersManager.
+     * @param opts.debug {boolean} - Whether debugging is enabled.
+     */
+    constructor(opts) {
         this.map = new Map();
-        this.debug = debug;
+        this.debug = opts?.debug || false;
     }
     /**
-     * Add a layer to the map
-     * @param layers {AnyLayer[]} - The `layer` or `group` to add to the map
+     * Adds layers or groups to the map.
+     * @param layers {Array<AnyLayer | Group>} - The layers or groups to add to the map.
+     * @returns {this} The current instance for chaining.
+     * @throws {LazyError} If a layer with the same ID already exists.
      */
     add(...layers) {
         if (this.debug)
@@ -21,7 +37,7 @@ class LayersManager {
         layersArray = layersArray.filter(l => l !== undefined);
         for (const layer of layersArray) {
             if (this.debug)
-                LazyUtil_1.LazyLog.log('none', `Data:`, layer.toJSON());
+                LazyUtil_1.LazyLog.log('none', `Data:`, 'toJSON' in layer ? layer.toJSON() : layer);
             if (this.map.has(layer.id))
                 throw new LazyUtil_1.LazyError("Layer already exists");
             this.map.set(layer.id, layer);
@@ -30,8 +46,9 @@ class LayersManager {
         return this;
     }
     /**
-     * Remove a layer from the map
-     * @param ids {string[]} - The `id` of the layer or group to remove
+     * Removes layers or groups from the map by their IDs.
+     * @param ids {string[]} - The IDs of the layers or groups to remove.
+     * @returns {this} The current instance for chaining.
      */
     remove(...ids) {
         for (const id of ids) {
@@ -40,16 +57,18 @@ class LayersManager {
         return this;
     }
     /**
-     * Clear all layers from the map
+     * Clears all layers and groups from the map.
+     * @returns {this} The current instance for chaining.
      */
     clear() {
         this.map.clear();
         return this;
     }
     /**
-     * Get a layer from the map
-     * @param id {string} - The `id` of the layer or group to get
-     * @param cross {boolean} - Whether to search in groups or not
+     * Retrieves a layer or group from the map by its ID.
+     * @param id {string} - The ID of the layer or group to retrieve.
+     * @param cross {boolean} - Whether to search within groups for the ID.
+     * @returns {AnyLayer | Group | undefined} The retrieved layer or group, or undefined if not found.
      */
     get(id, cross = false) {
         if (cross)
@@ -58,81 +77,100 @@ class LayersManager {
             return this.map.get(id);
     }
     /**
-     * Check if a layer exists in the map
-     * @param id {string} - The `id` of the layer or group to check
+     * Checks if a layer or group exists in the map by its ID.
+     * @param id {string} - The ID of the layer or group to check.
+     * @returns {boolean} True if the layer or group exists, false otherwise.
      */
     has(id) {
         return this.map.has(id);
     }
     /**
-     * Get the size of the map
+     * Retrieves the number of layers and groups in the map.
+     * @returns {number} The size of the map.
      */
     size() {
         return this.map.size;
     }
     /**
-     * Get the values of the map
+     * Retrieves the values (layers and groups) from the map.
+     * @returns {IterableIterator<AnyLayer | Group>} An iterator for the map values.
      */
     values() {
         return this.map.values();
     }
     /**
-     * Get the keys of the map
+     * Retrieves the keys (IDs) from the map.
+     * @returns {IterableIterator<string>} An iterator for the map keys.
      */
     keys() {
         return this.map.keys();
     }
     /**
-     * Get the entries of the map
+     * Retrieves the entries (key-value pairs) from the map.
+     * @returns {IterableIterator<[string, AnyLayer | Group]>} An iterator for the map entries.
      */
     entries() {
         return this.map.entries();
     }
     /**
-     * For each layer in the map
-     * @param callbackfn {Function} - The `callback` function to execute
+     * Executes a callback function for each layer or group in the map.
+     * @param callbackfn {Function} - The callback function to execute.
+     * @returns {this} The current instance for chaining.
      */
     forEach(callbackfn) {
         this.map.forEach(callbackfn);
         return this;
     }
     /**
-     * Convert the map to a JSON object
+     * Converts the map to a JSON object.
+     * @returns {object} The JSON representation of the map.
      */
     toJSON() {
         return Object.fromEntries(this.map);
     }
     /**
-     * Convert a JSON object to the map
-     * @param json {object} - The `json` object to convert
+     * Populates the map from a JSON object.
+     * @param json {object} - The JSON object to populate the map from.
+     * @returns {this} The current instance for chaining.
      */
     fromJSON(json) {
         this.map = new Map(Object.entries(json));
         return this;
     }
     /**
-     * Convert the map to an array
+     * Converts the map to an array of layers and groups.
+     * @returns {Array<AnyLayer | Group>} An array of layers and groups.
      */
     toArray() {
         return Array.from(this.map.values());
     }
     /**
-     * Convert an array to the map
-     * @param array {Array<AnyLayer>} - The `array` to convert
+     * Populates the map from an array of layers and groups.
+     * @param array {Array<AnyLayer | Group>} - The array of layers and groups to populate the map from.
+     * @returns {this} The current instance for chaining.
      */
     fromArray(array) {
         this.map = new Map(array.map(l => [l.id, l]));
         return this;
     }
+    /**
+     * Sorts the layers and groups in the map by their zIndex property.
+     * @returns {void}
+     */
     sort() {
         this.fromArray(this.toArray().sort((a, b) => a.zIndex - b.zIndex));
     }
+    /**
+     * Searches for a layer or group by its ID, including within groups.
+     * @param id {string} - The ID of the layer or group to search for.
+     * @returns {AnyLayer | Group | undefined} The found layer or group, or undefined if not found.
+     */
     crossSearch(id) {
-        for (const layer of this.map.values()) {
+        for (const layer of Array.from(this.map.values())) {
             if (layer.id === id)
                 return layer;
-            if (layer instanceof Group_1.Group) {
-                const result = layer.components.find(l => l.id === id);
+            if (layer instanceof components_1.Group) {
+                const result = layer.layers.find(l => l.id === id);
                 if (result)
                     return result;
             }

package/dist/structures/managers/RenderManager.d.ts

@@ -1,15 +1,72 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IRenderManager } from "../../types";
+import { AnyExport } from "../../types";
 import { LazyCanvas } from "../LazyCanvas";
-import { SKRSContext2D } from "@napi-rs/canvas";
+import { Canvas, SKRSContext2D, SvgCanvas } from "@napi-rs/canvas";
+/**
+ * Interface representing the RenderManager.
+ */
+export interface IRenderManager {
+    /**
+     * The LazyCanvas instance used for rendering.
+     */
+    lazyCanvas: LazyCanvas;
+    /**
+     * Whether debugging is enabled.
+     */
+    debug: boolean;
+}
+/**
+ * Class responsible for managing rendering operations, including static and animated exports.
+ */
 export declare class RenderManager implements IRenderManager {
+    /**
+     * The LazyCanvas instance used for rendering.
+     */
     lazyCanvas: LazyCanvas;
+    /**
+     * Whether debugging is enabled.
+     */
     debug: boolean;
-    constructor(lazyCanvas: LazyCanvas, debug?: boolean);
     /**
-     * This will render all the layers and return the rendered canvas buffer or ctx.
-     * @returns {Promise<Buffer | SKRSContext2D>}
+     * Constructs a new RenderManager instance.
+     * @param lazyCanvas {LazyCanvas} - The LazyCanvas instance to use for rendering.
+     * @param opts {Object} - Optional settings for the RenderManager.
+     * @param opts.debug {boolean} - Whether debugging is enabled.
+     */
+    constructor(lazyCanvas: LazyCanvas, opts?: {
+        debug?: boolean;
+    });
+    /**
+     * Merges multiple ImageData objects into a single ImageData object.
+     * @param ctx {SKRSContext2D} - The canvas rendering context.
+     * @param imageDataList {ImageData[]} - The list of ImageData objects to merge.
+     * @param width {number} - The width of the resulting ImageData.
+     * @param height {number} - The height of the resulting ImageData.
+     * @returns {ImageData} The merged ImageData object.
+     */
+    private mergeImageData;
+    /**
+     * Renders a single layer or group of layers.
+     * @param layer {AnyLayer | Group} - The layer or group to render.
+     * @returns {Promise<SKRSContext2D>} The canvas rendering context after rendering.
+     */
+    private renderLayer;
+    /**
+     * Renders all layers statically and exports the result in the specified format.
+     * @param exportType {AnyExport} - The export format (e.g., buffer, SVG, or context).
+     * @returns {Promise<Buffer | SKRSContext2D | string>} The rendered output in the specified format.
+     */
+    private renderStatic;
+    /**
+     * Renders an animated sequence of layers and exports it as a GIF.
+     * @returns {Promise<Buffer>} The rendered animation as a Buffer.
+     */
+    private renderAnimation;
+    /**
+     * Renders all layers and exports the result in the specified format.
+     * @param format {AnyExport} - The export format (e.g., buffer, context, SVG, or canvas).
+     * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The rendered output in the specified format.
      */
-    render(): Promise<Buffer | SKRSContext2D>;
+    render(format: AnyExport): Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>;
 }

package/dist/structures/managers/RenderManager.js

@@ -1,60 +1,189 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RenderManager = void 0;
-const enum_1 = require("../../types/enum");
-const Group_1 = require("../components/Group");
+const types_1 = require("../../types");
+const components_1 = require("../components");
 const LazyUtil_1 = require("../../utils/LazyUtil");
+// @ts-ignore
+const gifenc_1 = require("gifenc");
+/**
+ * Class responsible for managing rendering operations, including static and animated exports.
+ */
 class RenderManager {
+    /**
+     * The LazyCanvas instance used for rendering.
+     */
     lazyCanvas;
+    /**
+     * Whether debugging is enabled.
+     */
     debug;
-    constructor(lazyCanvas, debug = false) {
+    /**
+     * Constructs a new RenderManager instance.
+     * @param lazyCanvas {LazyCanvas} - The LazyCanvas instance to use for rendering.
+     * @param opts {Object} - Optional settings for the RenderManager.
+     * @param opts.debug {boolean} - Whether debugging is enabled.
+     */
+    constructor(lazyCanvas, opts) {
         this.lazyCanvas = lazyCanvas;
-        this.debug = debug;
+        this.debug = opts?.debug || false;
     }
     /**
-     * This will render all the layers and return the rendered canvas buffer or ctx.
-     * @returns {Promise<Buffer | SKRSContext2D>}
-     */
-    async render() {
-        for (const layer of this.lazyCanvas.layers.toArray()) {
-            if (this.debug)
-                LazyUtil_1.LazyLog.log('info', `Rendering ${layer.id}...\nData:`, layer.toJSON());
-            if (layer.visible) {
-                if (layer instanceof Group_1.Group) {
-                    for (const subLayer of layer.components) {
-                        if (subLayer.visible) {
-                            if (!subLayer.props.globalComposite)
-                                this.lazyCanvas.ctx.globalCompositeOperation = 'source-over';
-                            else
-                                this.lazyCanvas.ctx.globalCompositeOperation = subLayer.props.globalComposite;
-                            await subLayer.draw(this.lazyCanvas.ctx, this.lazyCanvas.canvas, this.lazyCanvas.layers, this.debug);
+     * Merges multiple ImageData objects into a single ImageData object.
+     * @param ctx {SKRSContext2D} - The canvas rendering context.
+     * @param imageDataList {ImageData[]} - The list of ImageData objects to merge.
+     * @param width {number} - The width of the resulting ImageData.
+     * @param height {number} - The height of the resulting ImageData.
+     * @returns {ImageData} The merged ImageData object.
+     */
+    mergeImageData(ctx, imageDataList, width, height) {
+        const mergedData = ctx.createImageData(width, height);
+        const mergedPixels = mergedData.data;
+        for (const imageData of imageDataList) {
+            const pixels = imageData.data;
+            for (let i = 0; i < pixels.length; i += 4) {
+                const r = pixels[i];
+                const g = pixels[i + 1];
+                const b = pixels[i + 2];
+                const a = pixels[i + 3] / 255;
+                const existingAlpha = mergedPixels[i + 3] / 255;
+                const newAlpha = a + existingAlpha * (1 - a);
+                if (newAlpha > 0) {
+                    mergedPixels[i] = (r * a + mergedPixels[i] * existingAlpha * (1 - a)) / newAlpha;
+                    mergedPixels[i + 1] = (g * a + mergedPixels[i + 1] * existingAlpha * (1 - a)) / newAlpha;
+                    mergedPixels[i + 2] = (b * a + mergedPixels[i + 2] * existingAlpha * (1 - a)) / newAlpha;
+                    mergedPixels[i + 3] = newAlpha * 255;
+                }
+            }
+        }
+        return mergedData;
+    }
+    /**
+     * Renders a single layer or group of layers.
+     * @param layer {AnyLayer | Group} - The layer or group to render.
+     * @returns {Promise<SKRSContext2D>} The canvas rendering context after rendering.
+     */
+    async renderLayer(layer) {
+        if (this.debug)
+            LazyUtil_1.LazyLog.log('info', `Rendering ${layer.id}...\nData:`, layer.toJSON());
+        if (layer.visible) {
+            if (layer instanceof components_1.Group) {
+                for (const subLayer of layer.layers) {
+                    if (subLayer.visible) {
+                        if ('globalComposite' in subLayer.props && subLayer.props.globalComposite) {
+                            this.lazyCanvas.ctx.globalCompositeOperation = subLayer.props.globalComposite;
+                        }
+                        else {
+                            this.lazyCanvas.ctx.globalCompositeOperation = 'source-over';
                         }
+                        await subLayer.draw(this.lazyCanvas.ctx, this.lazyCanvas.canvas, this.lazyCanvas.manager.layers, this.debug);
                     }
                 }
+            }
+            else {
+                if ('globalComposite' in layer.props && layer.props.globalComposite) {
+                    this.lazyCanvas.ctx.globalCompositeOperation = layer.props.globalComposite;
+                }
                 else {
-                    if (!layer.props.globalComposite)
-                        this.lazyCanvas.ctx.globalCompositeOperation = 'source-over';
-                    else
-                        this.lazyCanvas.ctx.globalCompositeOperation = layer.props.globalComposite;
-                    await layer.draw(this.lazyCanvas.ctx, this.lazyCanvas.canvas, this.lazyCanvas.layers, this.debug);
+                    this.lazyCanvas.ctx.globalCompositeOperation = 'source-over';
                 }
-                this.lazyCanvas.ctx.shadowColor = 'transparent';
+                await layer.draw(this.lazyCanvas.ctx, this.lazyCanvas.canvas, this.lazyCanvas.manager.layers, this.debug);
             }
+            this.lazyCanvas.ctx.shadowColor = 'transparent';
         }
-        switch (this.lazyCanvas.exportType) {
-            case enum_1.Export.Buffer:
+        return this.lazyCanvas.ctx;
+    }
+    /**
+     * Renders all layers statically and exports the result in the specified format.
+     * @param exportType {AnyExport} - The export format (e.g., buffer, SVG, or context).
+     * @returns {Promise<Buffer | SKRSContext2D | string>} The rendered output in the specified format.
+     */
+    async renderStatic(exportType) {
+        if (this.debug)
+            LazyUtil_1.LazyLog.log('info', `Rendering static...`);
+        for (const layer of this.lazyCanvas.manager.layers.toArray()) {
+            await this.renderLayer(layer);
+        }
+        switch (exportType) {
+            case types_1.Export.BUFFER:
             case "buffer":
+            case types_1.Export.SVG:
+            case "svg":
+                if ('getContent' in this.lazyCanvas.canvas) {
+                    return this.lazyCanvas.canvas.getContent().toString('utf8');
+                }
                 return this.lazyCanvas.canvas.toBuffer('image/png');
-            case enum_1.Export.CTX:
+            case types_1.Export.CTX:
             case "ctx":
                 return this.lazyCanvas.ctx;
-            case enum_1.Export.SVG:
-            case "svg":
-                // @ts-ignore
-                return this.lazyCanvas.canvas.getContent().toString('utf8');
             default:
+                if ('getContent' in this.lazyCanvas.canvas) {
+                    return this.lazyCanvas.canvas.getContent().toString('utf8');
+                }
                 return this.lazyCanvas.canvas.toBuffer('image/png');
         }
     }
+    /**
+     * Renders an animated sequence of layers and exports it as a GIF.
+     * @returns {Promise<Buffer>} The rendered animation as a Buffer.
+     */
+    async renderAnimation() {
+        const encoder = new gifenc_1.GIFEncoder();
+        if (this.debug)
+            LazyUtil_1.LazyLog.log('info', `Rendering animation...\nData:`, this.lazyCanvas.manager.animation.options);
+        const frameBuffer = [];
+        const { width, height } = this.lazyCanvas.options;
+        const delay = 1000 / this.lazyCanvas.manager.animation.options.frameRate;
+        const { loop, colorSpace, maxColors, transparency, utils } = this.lazyCanvas.manager.animation.options;
+        for (const layer of this.lazyCanvas.manager.layers.toArray()) {
+            const ctx = await this.renderLayer(layer);
+            frameBuffer.push(ctx.getImageData(0, 0, width, height));
+            if (frameBuffer.length > utils.buffer.size) {
+                frameBuffer.shift();
+            }
+            const mergeData = this.mergeImageData(ctx, frameBuffer, width, height);
+            const palette = (0, gifenc_1.quantize)(mergeData.data, maxColors, { format: colorSpace });
+            const index = (0, gifenc_1.applyPalette)(mergeData.data, palette, colorSpace);
+            encoder.writeFrame(index, width, height, {
+                palette,
+                transparent: transparency,
+                delay,
+                loop
+            });
+            if (utils.clear)
+                ctx.clearRect(0, 0, width, height);
+        }
+        encoder.finish();
+        return encoder.bytesView();
+    }
+    /**
+     * Renders all layers and exports the result in the specified format.
+     * @param format {AnyExport} - The export format (e.g., buffer, context, SVG, or canvas).
+     * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The rendered output in the specified format.
+     */
+    async render(format) {
+        switch (format) {
+            case types_1.Export.BUFFER:
+            case "buffer":
+                if (this.lazyCanvas.options.animated) {
+                    return await this.renderAnimation();
+                }
+                else {
+                    return await this.renderStatic(types_1.Export.BUFFER);
+                }
+            case types_1.Export.CTX:
+            case "ctx":
+                return this.lazyCanvas.ctx;
+            case types_1.Export.SVG:
+            case "svg":
+                return this.renderStatic(types_1.Export.SVG);
+            case types_1.Export.CANVAS:
+            case "canvas":
+                await this.renderStatic(this.lazyCanvas.options.exportType === 'svg' ? types_1.Export.SVG : types_1.Export.BUFFER);
+                return this.lazyCanvas.canvas;
+            default:
+                return this.renderStatic(types_1.Export.BUFFER);
+        }
+    }
 }
 exports.RenderManager = RenderManager;