@nmmty/lazycanvas 0.6.0-dev.f33019 → 0.6.0

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,10 +21,12 @@ class LayersManager {
     debug;
     /**
      * Constructs a new LayersManager instance.
+     * @param lazycanvas {LazyCanvas} - The LazyCanvas instance to associate with this manager.
      * @param opts {Object} - Optional settings for the LayersManager.
      * @param opts.debug {boolean} - Whether debugging is enabled.
      */
-    constructor(opts) {
+    constructor(lazycanvas, opts) {
+        this.lazycanvas = lazycanvas;
         this.map = new Map();
         this.debug = opts?.debug || false;
     }
@@ -41,6 +47,10 @@ 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;
@@ -52,7 +62,12 @@ class LayersManager {
      */
     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;
     }

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

@@ -0,0 +1,228 @@
+import { LazyCanvas } from "../LazyCanvas";
+import { AnyLayer } from "../../types";
+import { Group } from "../components";
+/**
+ * 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: any): 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 canvas - The LazyCanvas instance.
+     * @param opts - Optional settings for the PluginManager.
+     */
+    constructor(canvas: LazyCanvas, opts?: {
+        debug?: boolean;
+    });
+    /**
+     * Registers a plugin.
+     * @param 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 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.
+     * @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 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 hookName - The name of the hook to execute.
+     * @param 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,181 @@
+"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 canvas - The LazyCanvas instance.
+     * @param opts - Optional settings for the PluginManager.
+     */
+    constructor(canvas, opts) {
+        this.plugins = new Map();
+        this.debug = opts?.debug || false;
+        this.canvas = canvas;
+    }
+    /**
+     * Registers a plugin.
+     * @param 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 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 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 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 hookName - The name of the hook to execute.
+     * @param 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";

package/dist/structures/managers/RenderManager.js

@@ -114,7 +114,10 @@ class RenderManager {
         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;
+        let frameNumber = 0;
         for (const layer of this.lazyCanvas.manager.layers.toArray()) {
+            // onAnimationFrame hook
+            this.lazyCanvas.manager.plugins.executeHook('onAnimationFrame', this.lazyCanvas, frameNumber);
             const ctx = await this.renderLayer(layer);
             frameBuffer.push(ctx.getImageData(0, 0, width, height));
             if (frameBuffer.length > utils.buffer.size) {
@@ -131,6 +134,7 @@ class RenderManager {
             });
             if (utils.clear)
                 ctx.clearRect(0, 0, width, height);
+            frameNumber++;
         }
         encoder.finish();
         return encoder.bytesView();
@@ -141,28 +145,39 @@ class RenderManager {
      * @returns {Promise<Buffer | SKRSContext2D | Canvas | SvgCanvas | string>} The rendered output in the specified format.
      */
     async render(format) {
+        let result;
+        // beforeRender hook
+        this.lazyCanvas.manager.plugins.executeHook('beforeRender', this.lazyCanvas);
         switch (format) {
             case types_1.Export.BUFFER:
             case "buffer":
                 if (this.lazyCanvas.options.animated) {
-                    return await this.renderAnimation();
+                    result = await this.renderAnimation();
                 }
                 else {
-                    return await this.renderStatic(types_1.Export.BUFFER);
+                    result = await this.renderStatic(types_1.Export.BUFFER);
                 }
+                break;
             case types_1.Export.CTX:
             case "ctx":
-                return this.lazyCanvas.ctx;
+                result = this.lazyCanvas.ctx;
+                break;
             case types_1.Export.SVG:
             case "svg":
-                return this.renderStatic(types_1.Export.SVG);
+                result = await this.renderStatic(types_1.Export.SVG);
+                break;
             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;
+                result = this.lazyCanvas.canvas;
+                break;
             default:
-                return this.renderStatic(types_1.Export.BUFFER);
+                result = await this.renderStatic(types_1.Export.BUFFER);
+                break;
         }
+        // afterRender hook
+        this.lazyCanvas.manager.plugins.executeHook('afterRender', this.lazyCanvas);
+        return result;
     }
 }
 exports.RenderManager = RenderManager;

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export type * from "./types";
 export * from './enum';
+export * from '../structures/managers/PluginManager';

package/dist/types/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enum"), exports);
+__exportStar(require("../structures/managers/PluginManager"), exports);

package/dist/utils/utils.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resizeLayers = exports.resize = exports.getBoundingBoxBezier = exports.centring = exports.isImageUrlValid = exports.generateRandomName = exports.transform = exports.parseFillStyle = exports.filters = exports.opacity = exports.drawShadow = exports.parser = exports.parseToNormal = exports.isColor = exports.generateID = void 0;
+exports.generateID = generateID;
+exports.isColor = isColor;
+exports.parseToNormal = parseToNormal;
+exports.parser = parser;
+exports.drawShadow = drawShadow;
+exports.opacity = opacity;
+exports.filters = filters;
+exports.parseFillStyle = parseFillStyle;
+exports.transform = transform;
+exports.generateRandomName = generateRandomName;
+exports.isImageUrlValid = isImageUrlValid;
+exports.centring = centring;
+exports.getBoundingBoxBezier = getBoundingBoxBezier;
+exports.resize = resize;
+exports.resizeLayers = resizeLayers;
 const types_1 = require("../types");
 const helpers_1 = require("../structures/helpers");
 const canvas_1 = require("@napi-rs/canvas");
@@ -9,7 +23,6 @@ const components_1 = require("../structures/components");
 function generateID(type) {
     return `${type}-${Math.random().toString(36).substr(2, 9)}`;
 }
-exports.generateID = generateID;
 let percentReg = /^(\d+)%$/;
 let pxReg = /^(\d+)px$/;
 let canvasReg = /^(vw|vh|vmin|vmax)$/;
@@ -22,7 +35,6 @@ let hslaReg = /^hsla\((\d+),\s*(\d+)%,\s*(\d+)%,\s*(0|0?\.\d+|1(\.0)?)\)$/;
 function isColor(v) {
     return typeof (v === 'string' && (hexReg.test(v) || rgbReg.test(v) || rgbaReg.test(v) || hslReg.test(v) || hslaReg.test(v))) || v instanceof helpers_1.Gradient || v instanceof helpers_1.Pattern;
 }
-exports.isColor = isColor;
 function parseToNormal(v, ctx, canvas, layer = { width: 0, height: 0 }, options = { vertical: false, layer: false }, manager) {
     if (typeof v === 'number')
         return v;
@@ -78,7 +90,6 @@ function parseToNormal(v, ctx, canvas, layer = { width: 0, height: 0 }, options
     }
     return 0;
 }
-exports.parseToNormal = parseToNormal;
 function getLayerWidth(anyLayer, ctx, canvas, manager, parserInstance) {
     if (anyLayer instanceof components_1.LineLayer || anyLayer instanceof components_1.BezierLayer || anyLayer instanceof components_1.QuadraticLayer) {
         return anyLayer.getBoundingBox(ctx, canvas, manager).width;
@@ -112,7 +123,6 @@ function parser(ctx, canvas, manager) {
         }
     };
 }
-exports.parser = parser;
 function drawShadow(ctx, shadow) {
     if (shadow) {
         ctx.shadowColor = shadow.color;
@@ -121,19 +131,16 @@ function drawShadow(ctx, shadow) {
         ctx.shadowOffsetY = shadow.offsetY || 0;
     }
 }
-exports.drawShadow = drawShadow;
 function opacity(ctx, opacity = 1) {
     if (opacity < 1) {
         ctx.globalAlpha = opacity;
     }
 }
-exports.opacity = opacity;
 function filters(ctx, filters) {
     if (filters) {
         ctx.filter = filters;
     }
 }
-exports.filters = filters;
 function parseFillStyle(ctx, color, opts) {
     if (!ctx)
         throw new LazyUtil_1.LazyError('The context is not defined');
@@ -144,7 +151,6 @@ function parseFillStyle(ctx, color, opts) {
     }
     return color;
 }
-exports.parseFillStyle = parseFillStyle;
 function transform(ctx, transform, layer = { width: 0, height: 0, x: 0, y: 0, type: types_1.LayerType.Morph }, extra = { text: '', textAlign: types_1.TextAlign.Left, fontSize: 0, multiline: false }) {
     if (transform) {
         if (transform.translate) {
@@ -197,11 +203,9 @@ function transform(ctx, transform, layer = { width: 0, height: 0, x: 0, y: 0, ty
         }
     }
 }
-exports.transform = transform;
 function generateRandomName() {
     return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
 }
-exports.generateRandomName = generateRandomName;
 function isImageUrlValid(src) {
     try {
         (0, canvas_1.loadImage)(src);
@@ -211,7 +215,6 @@ function isImageUrlValid(src) {
         return false;
     }
 }
-exports.isImageUrlValid = isImageUrlValid;
 function centring(centring, type, width, height, x, y) {
     switch (centring) {
         case types_1.Centring.Center:
@@ -307,7 +310,6 @@ function centring(centring, type, width, height, x, y) {
             return { x, y };
     }
 }
-exports.centring = centring;
 function quadraticBezier(p0, p1, p2, t) {
     const x = (1 - t) ** 2 * p0.x + 2 * (1 - t) * t * p1.x + t ** 2 * p2.x;
     const y = (1 - t) ** 2 * p0.y + 2 * (1 - t) * t * p1.y + t ** 2 * p2.y;
@@ -339,7 +341,6 @@ function getBoundingBoxBezier(points, steps = 100) {
     }
     return { min: { x: minX, y: minY }, max: { x: maxX, y: maxY }, center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 }, width: maxX - minX, height: maxY - minY };
 }
-exports.getBoundingBoxBezier = getBoundingBoxBezier;
 function resize(value, ratio) {
     if (typeof value === 'number') {
         return value * ratio;
@@ -358,7 +359,6 @@ function resize(value, ratio) {
     }
     return value;
 }
-exports.resize = resize;
 function resizeLayers(layers, ratio) {
     let newLayers = [];
     if (layers.length > 0) {
@@ -411,4 +411,3 @@ function resizeLayers(layers, ratio) {
     }
     return newLayers;
 }
-exports.resizeLayers = resizeLayers;