@nmmty/lazycanvas 0.6.0-dev.f33019 → 0.6.1

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

@@ -1,9 +1,14 @@
 import { AnyLayer } from "../../types";
 import { Group } from "../components";
+import { LazyCanvas } from "../LazyCanvas";
 /**
  * Interface representing the LayersManager.
  */
 export interface ILayersManager {
+    /**
+     * The LazyCanvas instance associated with this manager.
+     */
+    lazyCanvas: LazyCanvas;
     /**
      * A map storing layers or groups with their IDs as keys.
      */
@@ -17,6 +22,10 @@ export interface ILayersManager {
  * Class representing a manager for handling layers and groups.
  */
 export declare class LayersManager implements ILayersManager {
+    /**
+     * The LazyCanvas instance associated with this manager.
+     */
+    lazyCanvas: LazyCanvas;
     /**
      * A map storing layers or groups with their IDs as keys.
      */
@@ -27,22 +36,23 @@ export declare class LayersManager implements ILayersManager {
     debug: boolean;
     /**
      * Constructs a new LayersManager instance.
-     * @param opts {Object} - Optional settings for the LayersManager.
-     * @param opts.debug {boolean} - Whether debugging is enabled.
+     * @param {LazyCanvas} [lazyCanvas] - The LazyCanvas instance to associate with this manager.
+     * @param {Object} [opts] - Optional settings for the LayersManager.
+     * @param {boolean} [opts.debug] - Whether debugging is enabled.
      */
-    constructor(opts?: {
+    constructor(lazyCanvas: LazyCanvas, opts?: {
         debug?: boolean;
     });
     /**
      * Adds layers or groups to the map.
-     * @param layers {Array<AnyLayer | Group>} - The layers or groups to add to the map.
+     * @param {Array<AnyLayer | Group>} [layers] - 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: Array<AnyLayer | Group>): this;
     /**
      * Removes layers or groups from the map by their IDs.
-     * @param ids {string[]} - The IDs of the layers or groups to remove.
+     * @param {string[]} [ids] - The IDs of the layers or groups to remove.
      * @returns {this} The current instance for chaining.
      */
     remove(...ids: string[]): this;
@@ -53,14 +63,14 @@ export declare class LayersManager implements ILayersManager {
     clear(): this;
     /**
      * 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.
+     * @param {string} [id] - The ID of the layer or group to retrieve.
+     * @param {boolean} [cross] - 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 | Group | undefined;
     /**
      * 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.
+     * @param {string} [id] - The ID of the layer or group to check.
      * @returns {boolean} True if the layer or group exists, false otherwise.
      */
     has(id: string): boolean;
@@ -86,7 +96,7 @@ export declare class LayersManager implements ILayersManager {
     entries(): IterableIterator<[string, AnyLayer | Group]>;
     /**
      * Executes a callback function for each layer or group in the map.
-     * @param callbackfn {Function} - The callback function to execute.
+     * @param {Function} [callbackfn] - The callback function to execute.
      * @returns {this} The current instance for chaining.
      */
     forEach(callbackfn: (value: AnyLayer | Group, key: string, map: Map<string, AnyLayer | Group>) => void): this;
@@ -97,7 +107,7 @@ export declare class LayersManager implements ILayersManager {
     toJSON(): object;
     /**
      * Populates the map from a JSON object.
-     * @param json {object} - The JSON object to populate the map from.
+     * @param {object} [json] - The JSON object to populate the map from.
      * @returns {this} The current instance for chaining.
      */
     fromJSON(json: object): this;
@@ -108,7 +118,7 @@ export declare class LayersManager implements ILayersManager {
     toArray(): Array<AnyLayer | Group>;
     /**
      * 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.
+     * @param {Array<AnyLayer | Group>} [array] - The array of layers and groups to populate the map from.
      * @returns {this} The current instance for chaining.
      */
     fromArray(array: Array<AnyLayer | Group>): this;
@@ -119,7 +129,7 @@ export declare class LayersManager implements ILayersManager {
     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.
+     * @param {string} [id] - 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

@@ -7,6 +7,10 @@ const LazyUtil_1 = require("../../utils/LazyUtil");
  * Class representing a manager for handling layers and groups.
  */
 class LayersManager {
+    /**
+     * The LazyCanvas instance associated with this manager.
+     */
+    lazyCanvas;
     /**
      * A map storing layers or groups with their IDs as keys.
      */
@@ -17,16 +21,18 @@ class LayersManager {
     debug;
     /**
      * Constructs a new LayersManager instance.
-     * @param opts {Object} - Optional settings for the LayersManager.
-     * @param opts.debug {boolean} - Whether debugging is enabled.
+     * @param {LazyCanvas} [lazyCanvas] - The LazyCanvas instance to associate with this manager.
+     * @param {Object} [opts] - Optional settings for the LayersManager.
+     * @param {boolean} [opts.debug] - Whether debugging is enabled.
      */
-    constructor(opts) {
+    constructor(lazyCanvas, opts) {
+        this.lazyCanvas = lazyCanvas;
         this.map = new Map();
         this.debug = opts?.debug || false;
     }
     /**
      * Adds layers or groups to the map.
-     * @param layers {Array<AnyLayer | Group>} - The layers or groups to add to the map.
+     * @param {Array<AnyLayer | Group>} [layers] - 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.
      */
@@ -41,18 +47,27 @@ class LayersManager {
             if (this.map.has(layer.id))
                 throw new LazyUtil_1.LazyError("Layer already exists");
             this.map.set(layer.id, layer);
+            // onLayerAdded hook
+            if (this.lazyCanvas && this.lazyCanvas.manager?.plugins) {
+                this.lazyCanvas.manager.plugins.executeHook('onLayerAdded', this.lazyCanvas, layer);
+            }
         }
         this.sort();
         return this;
     }
     /**
      * Removes layers or groups from the map by their IDs.
-     * @param ids {string[]} - The IDs of the layers or groups to remove.
+     * @param {string[]} [ids] - The IDs of the layers or groups to remove.
      * @returns {this} The current instance for chaining.
      */
     remove(...ids) {
         for (const id of ids) {
+            const layer = this.map.get(id);
             this.map.delete(id);
+            // onLayerRemoved hook
+            if (this.lazyCanvas && this.lazyCanvas.manager?.plugins) {
+                this.lazyCanvas.manager.plugins.executeHook('onLayerRemoved', this.lazyCanvas, id);
+            }
         }
         return this;
     }
@@ -66,8 +81,8 @@ class LayersManager {
     }
     /**
      * 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.
+     * @param {string} [id] - The ID of the layer or group to retrieve.
+     * @param {boolean} [cross] - 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) {
@@ -78,7 +93,7 @@ class LayersManager {
     }
     /**
      * 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.
+     * @param {string} [id] - The ID of the layer or group to check.
      * @returns {boolean} True if the layer or group exists, false otherwise.
      */
     has(id) {
@@ -114,7 +129,7 @@ class LayersManager {
     }
     /**
      * Executes a callback function for each layer or group in the map.
-     * @param callbackfn {Function} - The callback function to execute.
+     * @param {Function} [callbackfn] - The callback function to execute.
      * @returns {this} The current instance for chaining.
      */
     forEach(callbackfn) {
@@ -130,7 +145,7 @@ class LayersManager {
     }
     /**
      * Populates the map from a JSON object.
-     * @param json {object} - The JSON object to populate the map from.
+     * @param {object} [json] - The JSON object to populate the map from.
      * @returns {this} The current instance for chaining.
      */
     fromJSON(json) {
@@ -146,7 +161,7 @@ class LayersManager {
     }
     /**
      * 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.
+     * @param {Array<AnyLayer | Group>} [array] - The array of layers and groups to populate the map from.
      * @returns {this} The current instance for chaining.
      */
     fromArray(array) {
@@ -162,7 +177,7 @@ class LayersManager {
     }
     /**
      * 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.
+     * @param {string} [id] - 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) {

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

@@ -0,0 +1,230 @@
+import { LazyCanvas } from "../LazyCanvas";
+import { AnyLayer } from "../../types";
+import { Group } from "../components";
+import { Canvas, SKRSContext2D, SvgCanvas } from "@napi-rs/canvas";
+/**
+ * Interface representing a LazyCanvas plugin.
+ */
+export interface ILazyCanvasPlugin {
+    /**
+     * The unique name of the plugin.
+     */
+    name: string;
+    /**
+     * The version of the plugin.
+     */
+    version: string;
+    /**
+     * Optional description of the plugin.
+     */
+    description?: string;
+    /**
+     * Optional author of the plugin.
+     */
+    author?: string;
+    /**
+     * Optional dependencies on other plugins.
+     */
+    dependencies?: string[];
+    /**
+     * Optional configuration object for the plugin.
+     */
+    config?: any;
+    /**
+     * Optional private data storage for the plugin.
+     */
+    private?: any;
+    /**
+     * Method called when the plugin is installed.
+     * @param canvas - The LazyCanvas instance.
+     * @returns true if installation was successful, false otherwise.
+     */
+    install(canvas: LazyCanvas): boolean;
+    /**
+     * Optional method called when the plugin is uninstalled.
+     * @param canvas - The LazyCanvas instance.
+     * @returns true if uninstallation was successful, false otherwise.
+     */
+    uninstall?(canvas: LazyCanvas): boolean;
+    /**
+     * Optional hooks for lifecycle events.
+     */
+    hooks?: IPluginHooks;
+}
+/**
+ * Interface representing plugin hooks for lifecycle events.
+ */
+export interface IPluginHooks {
+    /**
+     * Called before rendering starts.
+     */
+    beforeRender?(canvas: LazyCanvas): void;
+    /**
+     * Called after rendering completes.
+     */
+    afterRender?(canvas: LazyCanvas): void;
+    /**
+     * Called before export starts.
+     */
+    beforeExport?(canvas: LazyCanvas): void;
+    /**
+     * Called after export completes.
+     */
+    afterExport?(canvas: LazyCanvas, result: string | Buffer<ArrayBufferLike> | SKRSContext2D | Canvas | SvgCanvas): void;
+    /**
+     * Called when canvas is resized.
+     */
+    onResize?(canvas: LazyCanvas, ratio: number): void;
+    /**
+     * Called when a layer is added.
+     */
+    onLayerAdded?(canvas: LazyCanvas, layer: AnyLayer | Group): void;
+    /**
+     * Called when a layer is removed.
+     */
+    onLayerRemoved?(canvas: LazyCanvas, layerId: string): void;
+    /**
+     * Called when canvas is created/recreated.
+     */
+    onCanvasCreated?(canvas: LazyCanvas, width: number, height: number): void;
+    /**
+     * Called when a layer is modified.
+     */
+    onLayerModified?(canvas: LazyCanvas, layer: AnyLayer | Group): void;
+    /**
+     * Called when animation frame is processed.
+     */
+    onAnimationFrame?(canvas: LazyCanvas, frame: number): void;
+    /**
+     * Called when an error occurs.
+     */
+    onError?(canvas: LazyCanvas, error: Error): void;
+}
+/**
+ * Interface representing the PluginManager.
+ */
+export interface IPluginManager {
+    /**
+     * A map storing installed plugins with their names as keys.
+     */
+    plugins: Map<string, ILazyCanvasPlugin>;
+    /**
+     * Whether debugging is enabled.
+     */
+    debug: boolean;
+    /**
+     * Reference to the LazyCanvas instance.
+     */
+    canvas: LazyCanvas;
+    /**
+     * Registers a plugin.
+     * @param plugin - The plugin to register.
+     */
+    register(plugin: ILazyCanvasPlugin): void;
+    /**
+     * Unregisters a plugin by name.
+     * @param pluginName - The name of the plugin to unregister.
+     * @throws {LazyError} If the plugin is not found or if other plugins depend on it.
+     */
+    unregister(pluginName: string): void;
+    /**
+     * Gets a plugin by name.
+     * @param pluginName - The name of the plugin.
+     */
+    get(pluginName: string): ILazyCanvasPlugin | undefined;
+    /**
+     * Lists all registered plugin names.
+     */
+    list(): string[];
+    /**
+     * Checks if a plugin is registered.
+     * @param pluginName - The name of the plugin.
+     */
+    has(pluginName: string): boolean;
+    /**
+     * Executes a hook for all plugins that implement it.
+     * @param hookName - The name of the hook to execute.
+     * @param args - Arguments to pass to the hook.
+     */
+    executeHook(hookName: keyof IPluginHooks, ...args: any[]): void;
+}
+/**
+ * Class representing a manager for handling plugins.
+ */
+export declare class PluginManager implements IPluginManager {
+    /**
+     * A map storing installed plugins with their names as keys.
+     */
+    plugins: Map<string, ILazyCanvasPlugin>;
+    /**
+     * Whether debugging is enabled.
+     */
+    debug: boolean;
+    /**
+     * Reference to the LazyCanvas instance.
+     */
+    canvas: LazyCanvas;
+    /**
+     * Constructs a new PluginManager instance.
+     * @param {LazyCanvas} [canvas] - The LazyCanvas instance.
+     * @param {Object} [opts] - Optional settings for the PluginManager.
+     * @param {boolean} [opts.debug] - Whether debugging is enabled.
+     */
+    constructor(canvas: LazyCanvas, opts?: {
+        debug?: boolean;
+    });
+    /**
+     * Registers a plugin.
+     * @param {ILazyCanvasPlugin} [plugin] - The plugin to register.
+     * @throws {LazyError} If a plugin with the same name is already registered.
+     */
+    register(plugin: ILazyCanvasPlugin): void;
+    /**
+     * Unregisters a plugin by name.
+     * @param {string} [pluginName] - The name of the plugin to unregister.
+     * @throws {LazyError} If the plugin is not found or if other plugins depend on it.
+     */
+    unregister(pluginName: string): void;
+    /**
+     * Gets a plugin by name.
+     * @param {string} [pluginName] - The name of the plugin.
+     * @returns The plugin or undefined if not found.
+     */
+    get(pluginName: string): ILazyCanvasPlugin | undefined;
+    /**
+     * Lists all registered plugin names.
+     * @returns Array of plugin names.
+     */
+    list(): string[];
+    /**
+     * Checks if a plugin is registered.
+     * @param {string} [pluginName] - The name of the plugin.
+     * @returns True if the plugin is registered, false otherwise.
+     */
+    has(pluginName: string): boolean;
+    /**
+     * Executes a hook for all plugins that implement it.
+     * @param {keyof IPluginHooks} [hookName] - The name of the hook to execute.
+     * @param {any} [args] - Arguments to pass to the hook.
+     */
+    executeHook(hookName: keyof IPluginHooks, ...args: any[]): void;
+    /**
+     * Executes the onError hook for all plugins when an error occurs.
+     * @param error - The error that occurred.
+     */
+    private executeErrorHook;
+    /**
+     * Gets plugin information.
+     * @returns Array of plugin information objects.
+     */
+    getPluginInfo(): Array<{
+        name: string;
+        version: string;
+        description?: string;
+        dependencies?: string[];
+    }>;
+    /**
+     * Clears all plugins.
+     */
+    clear(): void;
+}

package/dist/structures/managers/PluginManager.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const LazyUtil_1 = require("../../utils/LazyUtil");
+/**
+ * Class representing a manager for handling plugins.
+ */
+class PluginManager {
+    /**
+     * A map storing installed plugins with their names as keys.
+     */
+    plugins;
+    /**
+     * Whether debugging is enabled.
+     */
+    debug;
+    /**
+     * Reference to the LazyCanvas instance.
+     */
+    canvas;
+    /**
+     * Constructs a new PluginManager instance.
+     * @param {LazyCanvas} [canvas] - The LazyCanvas instance.
+     * @param {Object} [opts] - Optional settings for the PluginManager.
+     * @param {boolean} [opts.debug] - Whether debugging is enabled.
+     */
+    constructor(canvas, opts) {
+        this.plugins = new Map();
+        this.debug = opts?.debug || false;
+        this.canvas = canvas;
+    }
+    /**
+     * Registers a plugin.
+     * @param {ILazyCanvasPlugin} [plugin] - The plugin to register.
+     * @throws {LazyError} If a plugin with the same name is already registered.
+     */
+    register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new LazyUtil_1.LazyError(`Plugin '${plugin.name}' is already registered`);
+        }
+        // Check dependencies
+        if (plugin.dependencies) {
+            for (const dependency of plugin.dependencies) {
+                if (!this.plugins.has(dependency)) {
+                    throw new LazyUtil_1.LazyError(`Plugin '${plugin.name}' requires dependency '${dependency}' which is not installed`);
+                }
+            }
+        }
+        try {
+            const result = plugin.install(this.canvas);
+            this.plugins.set(plugin.name, plugin);
+            if (this.debug) {
+                LazyUtil_1.LazyLog.log('info', `Plugin '${plugin.name}' v${plugin.version} registered successfully`);
+            }
+        }
+        catch (error) {
+            throw new LazyUtil_1.LazyError(`Failed to install plugin '${plugin.name}': ${error}`);
+        }
+    }
+    /**
+     * Unregisters a plugin by name.
+     * @param {string} [pluginName] - The name of the plugin to unregister.
+     * @throws {LazyError} If the plugin is not found or if other plugins depend on it.
+     */
+    unregister(pluginName) {
+        const plugin = this.plugins.get(pluginName);
+        if (!plugin) {
+            throw new LazyUtil_1.LazyError(`Plugin '${pluginName}' is not registered`);
+        }
+        // Check if other plugins depend on this one
+        this.plugins.forEach((p, name) => {
+            if (name !== pluginName && p.dependencies?.includes(pluginName)) {
+                throw new LazyUtil_1.LazyError(`Cannot unregister plugin '${pluginName}' because plugin '${name}' depends on it`);
+            }
+        });
+        try {
+            if (plugin.uninstall) {
+                plugin.uninstall(this.canvas);
+            }
+            this.plugins.delete(pluginName);
+            if (this.debug) {
+                LazyUtil_1.LazyLog.log('info', `Plugin '${pluginName}' unregistered successfully`);
+            }
+        }
+        catch (error) {
+            throw new LazyUtil_1.LazyError(`Failed to uninstall plugin '${pluginName}': ${error}`);
+        }
+    }
+    /**
+     * Gets a plugin by name.
+     * @param {string} [pluginName] - The name of the plugin.
+     * @returns The plugin or undefined if not found.
+     */
+    get(pluginName) {
+        return this.plugins.get(pluginName);
+    }
+    /**
+     * Lists all registered plugin names.
+     * @returns Array of plugin names.
+     */
+    list() {
+        return Array.from(this.plugins.keys());
+    }
+    /**
+     * Checks if a plugin is registered.
+     * @param {string} [pluginName] - The name of the plugin.
+     * @returns True if the plugin is registered, false otherwise.
+     */
+    has(pluginName) {
+        return this.plugins.has(pluginName);
+    }
+    /**
+     * Executes a hook for all plugins that implement it.
+     * @param {keyof IPluginHooks} [hookName] - The name of the hook to execute.
+     * @param {any} [args] - Arguments to pass to the hook.
+     */
+    executeHook(hookName, ...args) {
+        this.plugins.forEach(plugin => {
+            try {
+                const hook = plugin.hooks?.[hookName];
+                if (hook) {
+                    hook(...args);
+                }
+            }
+            catch (error) {
+                if (this.debug) {
+                    LazyUtil_1.LazyLog.log('error', `Error executing hook '${hookName}' for plugin '${plugin.name}': ${error}`);
+                }
+                // Execute onError hook for all plugins when a hook fails
+                this.executeErrorHook(error);
+            }
+        });
+    }
+    /**
+     * Executes the onError hook for all plugins when an error occurs.
+     * @param error - The error that occurred.
+     */
+    executeErrorHook(error) {
+        this.plugins.forEach(plugin => {
+            try {
+                const errorHook = plugin.hooks?.onError;
+                if (errorHook) {
+                    errorHook(this.canvas, error);
+                }
+            }
+            catch (hookError) {
+                if (this.debug) {
+                    LazyUtil_1.LazyLog.log('error', `Error in onError hook for plugin '${plugin.name}': ${hookError}`);
+                }
+            }
+        });
+    }
+    /**
+     * Gets plugin information.
+     * @returns Array of plugin information objects.
+     */
+    getPluginInfo() {
+        return Array.from(this.plugins.values()).map(plugin => ({
+            name: plugin.name,
+            version: plugin.version,
+            description: plugin.description,
+            dependencies: plugin.dependencies
+        }));
+    }
+    /**
+     * Clears all plugins.
+     */
+    clear() {
+        const pluginNames = this.list();
+        for (const name of pluginNames) {
+            try {
+                this.unregister(name);
+            }
+            catch (error) {
+                if (this.debug) {
+                    LazyUtil_1.LazyLog.log('error', `Error unregistering plugin '${name}': ${error}`);
+                }
+            }
+        }
+    }
+}
+exports.PluginManager = PluginManager;

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

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { AnyExport } from "../../types";
 import { LazyCanvas } from "../LazyCanvas";
 import { Canvas, SKRSContext2D, SvgCanvas } from "@napi-rs/canvas";
@@ -30,31 +28,31 @@ export declare class RenderManager implements IRenderManager {
     debug: boolean;
     /**
      * 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.
+     * @param {LazyCanvas} [lazyCanvas] - The LazyCanvas instance to use for rendering.
+     * @param {Object} [opts] - Optional settings for the RenderManager.
+     * @param {boolean} [opts.debug] - 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.
+     * @param {SKRSContext2D} [ctx] - The canvas rendering context.
+     * @param {ImageData[]} [imageDataList] - The list of ImageData objects to merge.
+     * @param {number} [width] - The width of the resulting ImageData.
+     * @param {number} [height] - 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.
+     * @param {AnyLayer | Group} [layer] - 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).
+     * @param {AnyExport} [exportType] - The export format (e.g., buffer, SVG, or context).
      * @returns {Promise<Buffer | SKRSContext2D | string>} The rendered output in the specified format.
      */
     private renderStatic;
@@ -65,7 +63,7 @@ export declare class RenderManager implements IRenderManager {
     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).
+     * @param {AnyExport} [format] - 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(format: AnyExport): Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>;