apexify.js 4.5.44 → 4.5.50

package/dist/esm/canvas/ApexPainter.js

@@ -0,0 +1,769 @@
+import { createCanvas, loadImage, GlobalFonts } from "@napi-rs/canvas";
+import GIFEncoder from "gifencoder";
+import ffmpeg from 'fluent-ffmpeg';
+import { PassThrough } from "stream";
+import axios from 'axios';
+import fs from "fs";
+import path from "path";
+import { drawBackgroundGradient, drawBackgroundColor, customBackground, circularBorder, radiusBorder, customLines, applyRotation, applyStroke, applyShadow, imageRadius, drawShape, drawText, converter, resizingImg, applyColorFilters, imgEffects, verticalBarChart, pieChart, lineChart, cropInner, cropOuter, bgRemoval, detectColors, removeColor, dataURL, base64, arrayBuffer, blob, url } from "./utils/utils";
+export class ApexPainter {
+    format;
+    constructor({ type } = { type: 'buffer' }) {
+        this.format = { type: type || 'buffer' };
+    }
+    async createCanvas(canvas) {
+        let canvasWidth = canvas.width || 500;
+        let canvasHeight = canvas.height || 500;
+        let borderRadius = canvas.borderRadius || 0;
+        const canvasInstance = createCanvas(canvasWidth, canvasHeight);
+        const ctx = canvasInstance.getContext('2d');
+        if (!ctx) {
+            throw new Error('Unable to get 2D rendering context from canvas');
+        }
+        applyRotation(ctx, canvas.rotation || 0, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+        applyShadow(ctx, canvas.shadow, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+        if (typeof borderRadius === 'string') {
+            circularBorder(ctx, canvasWidth, canvasHeight);
+        }
+        else if (typeof borderRadius === 'number') {
+            radiusBorder(ctx, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight, borderRadius);
+        }
+        if (canvas.customBg) {
+            await customBackground(ctx, canvas);
+        }
+        else if (canvas.gradientBg) {
+            await drawBackgroundGradient(ctx, canvas);
+        }
+        else {
+            await drawBackgroundColor(ctx, canvas);
+        }
+        applyStroke(ctx, canvas.stroke, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+        return { buffer: canvasInstance.toBuffer('image/png'), canvas };
+    }
+    async createImage(images, canvasBuffer) {
+        if (!Array.isArray(images)) {
+            images = [images];
+        }
+        let existingCanvas;
+        if (Buffer.isBuffer(canvasBuffer)) {
+            existingCanvas = await loadImage(canvasBuffer);
+        }
+        else if (canvasBuffer && canvasBuffer.buffer) {
+            existingCanvas = await loadImage(canvasBuffer.buffer);
+        }
+        else {
+            throw new Error('Invalid canvasBuffer provided, should be Buffer or CanvasResults object with buffer');
+        }
+        if (!existingCanvas) {
+            throw new Error('Unable to load image from buffer');
+        }
+        const canvas = createCanvas(existingCanvas.width, existingCanvas.height);
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Unable to get 2D rendering context from canvas');
+        }
+        ctx.drawImage(existingCanvas, 0, 0);
+        for (const image of images) {
+            await this.drawImage(ctx, image);
+        }
+        return canvas.toBuffer('image/png');
+    }
+    async createText(textOptionsArray, buffer) {
+        try {
+            if (!Array.isArray(textOptionsArray)) {
+                textOptionsArray = [textOptionsArray];
+            }
+            let existingImage;
+            if (Buffer.isBuffer(buffer)) {
+                existingImage = await loadImage(buffer);
+            }
+            else if (buffer && buffer.buffer) {
+                existingImage = await loadImage(buffer.buffer);
+            }
+            else {
+                throw new Error('Invalid canvasBuffer provided. It should be a Buffer or CanvasResults object with a buffer');
+            }
+            if (!existingImage) {
+                throw new Error('Unable to load image from buffer');
+            }
+            const canvas = createCanvas(existingImage.width, existingImage.height);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(existingImage, 0, 0);
+            for (const textOptions of textOptionsArray) {
+                const mergedTextOptions = textOptions;
+                if (mergedTextOptions.fontPath) {
+                    GlobalFonts.registerFromPath(path.join(process.cwd(), mergedTextOptions.fontPath), mergedTextOptions.fontName);
+                }
+                const size = { width: existingImage.width, height: existingImage.height };
+                drawText(ctx, mergedTextOptions, size);
+            }
+            return canvas.toBuffer("image/png");
+        }
+        catch (error) {
+            console.error("Error loading existing image:", error);
+            throw new Error("Invalid image buffer");
+        }
+    }
+    async createCustom(options, buffer) {
+        try {
+            if (!Array.isArray(options)) {
+                options = [options];
+            }
+            let existingImage;
+            if (Buffer.isBuffer(buffer)) {
+                existingImage = await loadImage(buffer);
+            }
+            else if (buffer && buffer.buffer) {
+                existingImage = await loadImage(buffer.buffer);
+            }
+            else {
+                throw new Error('Invalid canvasBuffer provided. It should be a Buffer or CanvasResults object with a buffer');
+            }
+            if (!existingImage) {
+                throw new Error('Unable to load image from buffer');
+            }
+            const canvas = createCanvas(existingImage.width, existingImage.height);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(existingImage, 0, 0);
+            customLines(ctx, options);
+            return canvas.toBuffer("image/png");
+        }
+        catch (error) {
+            console.error("Error creating custom image:", error);
+            throw new Error("Failed to create custom image");
+        }
+    }
+    async createGIF(gifFrames, options) {
+        async function resizeImage(image, targetWidth, targetHeight) {
+            const canvas = createCanvas(targetWidth, targetHeight);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(image, 0, 0, targetWidth, targetHeight);
+            return canvas;
+        }
+        function createOutputStream(outputFile) {
+            return fs.createWriteStream(outputFile);
+        }
+        function createBufferStream() {
+            const bufferStream = new PassThrough();
+            const chunks = [];
+            bufferStream.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            return {
+                ...bufferStream,
+                getBuffer: function () {
+                    return Buffer.concat(chunks);
+                }
+            };
+        }
+        function validateOptions(options) {
+            if (options.outputFormat === "file" && !options.outputFile) {
+                throw new Error("Output file path is required when using file output format.");
+            }
+            if (options.repeat !== undefined && (typeof options.repeat !== "number" || options.repeat < 0)) {
+                throw new Error("Repeat must be a non-negative number or undefined.");
+            }
+            if (options.quality !== undefined && (typeof options.quality !== "number" || options.quality < 1 || options.quality > 20)) {
+                throw new Error("Quality must be a number between 1 and 20 or undefined.");
+            }
+            if (options.watermark && typeof options.watermark.enable !== "boolean") {
+                throw new Error("Watermark must be a boolean or undefined.");
+            }
+            if (options.textOverlay) {
+                const textOptions = options.textOverlay;
+                if (!textOptions.text || typeof textOptions.text !== "string") {
+                    throw new Error("Text overlay text is required and must be a string.");
+                }
+                if (textOptions.fontSize !== undefined && (!Number.isInteger(textOptions.fontSize) || textOptions.fontSize <= 0)) {
+                    throw new Error("Text overlay fontSize must be a positive integer or undefined.");
+                }
+                if (textOptions.fontColor !== undefined && typeof textOptions.fontColor !== "string") {
+                    throw new Error("Text overlay fontColor must be a string or undefined.");
+                }
+            }
+        }
+        try {
+            validateOptions(options);
+            const canvasWidth = options.width || 1200;
+            const canvasHeight = options.height || 1200;
+            const encoder = new GIFEncoder(canvasWidth, canvasHeight);
+            const outputStream = options.outputFile ? createOutputStream(options.outputFile) : createBufferStream();
+            encoder.createReadStream().pipe(outputStream);
+            encoder.start();
+            encoder.setRepeat(options.repeat || 0);
+            encoder.setQuality(options.quality || 10);
+            const canvas = createCanvas(canvasWidth, canvasHeight);
+            const ctx = canvas.getContext("2d");
+            for (const frame of gifFrames) {
+                const image = await loadImage(frame.background);
+                const resizedImage = await resizeImage(image, canvasWidth, canvasHeight);
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                ctx.drawImage(resizedImage, 0, 0);
+                if (options.watermark?.enable) {
+                    const watermark = await loadImage(options.watermark.url);
+                    ctx.drawImage(watermark, 10, canvasHeight - watermark.height - 10);
+                }
+                if (options.textOverlay) {
+                    ctx.font = `${options.textOverlay.fontSize || 20}px Arial`;
+                    ctx.fillStyle = options.textOverlay.fontColor || "white";
+                    ctx.fillText(options.textOverlay.text, options.textOverlay.x || 10, options.textOverlay.y || 30);
+                }
+                encoder.setDelay(frame.duration);
+                encoder.addFrame(ctx);
+            }
+            encoder.finish();
+            outputStream.end();
+            if (options.outputFormat === "file") {
+                await new Promise((resolve) => outputStream.on("finish", resolve));
+            }
+            else if (options.outputFormat === "base64") {
+                if ('getBuffer' in outputStream) {
+                    return outputStream.getBuffer().toString("base64");
+                }
+            }
+            else if (options.outputFormat === "attachment") {
+                const gifStream = encoder.createReadStream();
+                return [{ attachment: gifStream, name: "gif.js" }];
+            }
+            else if (options.outputFormat === "buffer") {
+                if ('getBuffer' in outputStream) {
+                    return outputStream.getBuffer();
+                }
+            }
+            else {
+                throw new Error("Invalid output format. Supported formats are 'file', 'base64', 'attachment', and 'buffer'.");
+            }
+        }
+        catch (e) {
+            console.error(e.message);
+            throw e; // Re-throw the error after logging
+        }
+    }
+    async resize(resizeOptions) {
+        return resizingImg(resizeOptions);
+    }
+    async imgConverter(imagePath, newExtension) {
+        return converter(imagePath, newExtension);
+    }
+    async processImage(imagePath, filters) {
+        return imgEffects(imagePath, filters);
+    }
+    async colorsFilter(imagePath, filterColor, opacity) {
+        return applyColorFilters(imagePath, filterColor, opacity);
+    }
+    async colorAnalysis(imagePath) {
+        return detectColors(imagePath);
+    }
+    async colorsRemover(imagePath, colorToRemove) {
+        return removeColor(imagePath, colorToRemove);
+    }
+    async removeBackground(imageURL, apiKey) {
+        return bgRemoval(imageURL, apiKey);
+    }
+    async blend(layers, baseImageBuffer) {
+        try {
+            // Load the base image
+            const baseImage = await loadImage(baseImageBuffer);
+            const canvas = createCanvas(baseImage.width, baseImage.height);
+            const ctx = canvas.getContext('2d');
+            // Draw the base image
+            ctx.drawImage(baseImage, 0, 0);
+            // Process each layer
+            for (const layer of layers) {
+                const layerImage = await loadImage(layer.image);
+                ctx.globalAlpha = layer.opacity !== undefined ? layer.opacity : 1.0;
+                ctx.globalCompositeOperation = layer.blendMode;
+                ctx.drawImage(layerImage, layer.position?.x || 0, layer.position?.y || 0);
+            }
+            ctx.globalAlpha = 1.0;
+            ctx.globalCompositeOperation = 'source-over';
+            return canvas.toBuffer('image/png');
+        }
+        catch (error) {
+            console.error('Error creating layered composition:', error);
+            throw new Error('Failed to create layered composition');
+        }
+    }
+    async createChart(data, type) {
+        if (!data || Object.keys(data).length === 0) {
+            throw new Error('You need to provide datasets to create charts.');
+        }
+        if (!type || !type.chartNumber || !type.chartType) {
+            throw new Error('Type arguments are missing.');
+        }
+        const { chartType, chartNumber } = type;
+        switch (chartType.toLowerCase()) {
+            case 'bar':
+                switch (chartNumber) {
+                    case 1:
+                        return await verticalBarChart(data);
+                    case 2:
+                        throw new Error('Type 2 is still under development.');
+                    default:
+                        throw new Error('Invalid chart number for chart type "bar".');
+                }
+            case 'line':
+                switch (chartNumber) {
+                    case 1:
+                        return await lineChart(data);
+                    case 2:
+                        throw new Error('Type 2 is still under development.');
+                    default:
+                        throw new Error('Invalid chart number for chart type "line".');
+                }
+            case 'pie':
+                switch (chartNumber) {
+                    case 1:
+                        return await pieChart(data);
+                    case 2:
+                        throw new Error('Type 2 is still under development.');
+                    default:
+                        throw new Error('Invalid chart number for chart type "pie".');
+                }
+            default:
+                throw new Error(`Unsupported chart type "${chartType}".`);
+        }
+    }
+    async cropImage(options) {
+        try {
+            if (!options.imageSource)
+                throw new Error('The "imageSource" option is needed. Please provide the path to the image to crop.');
+            if (!options.coordinates || options.coordinates.length < 3)
+                throw new Error('The "coordinates" option is needed. Please provide coordinates to crop the image.');
+            if (options.crop === 'outer') {
+                return await cropOuter(options);
+            }
+            else if (options.crop === 'inner') {
+                return await cropInner(options);
+            }
+            else {
+                throw new Error('Invalid crop option. Please specify "inner" or "outer".');
+            }
+        }
+        catch (error) {
+            console.error('An error occurred:', error);
+            throw error;
+        }
+    }
+    async drawImage(ctx, image) {
+        const { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition, opacity } = image;
+        if (!source || typeof x !== 'number' || typeof y !== 'number' || typeof width !== 'number' || typeof height !== 'number') {
+            throw new Error('Invalid image properties');
+        }
+        let img = undefined;
+        try {
+            const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
+            const isShape = shapeNames.includes(source.toLowerCase());
+            if (opacity) {
+                ctx.globalAlpha = opacity;
+            }
+            if (source.startsWith('http')) {
+                img = await loadImage(source);
+            }
+            else if (isShape) {
+                drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition });
+            }
+            else {
+                const imagePath = path.join(process.cwd(), source);
+                try {
+                    img = await loadImage(imagePath);
+                }
+                catch (e) {
+                    throw new Error(`Error loading image: ${e.message}`);
+                }
+            }
+            if (img) {
+                ctx.save();
+                applyRotation(ctx, rotation || 0, x, y, width, height);
+                applyShadow(ctx, shadow, x, y, width, height);
+                imageRadius(ctx, img, x, y, width, height, borderRadius || 0, borderPosition);
+                applyStroke(ctx, stroke, x, y, width, height);
+                ctx.restore();
+            }
+            else if (!isShape) {
+                throw new Error('Invalid image source or shape name');
+            }
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+        finally {
+            ctx.globalAlpha = 1.0;
+        }
+    }
+    async extractFrames(videoSource, options) {
+        const frames = [];
+        const frameDir = path.join(__dirname, 'frames');
+        if (!fs.existsSync(frameDir)) {
+            fs.mkdirSync(frameDir);
+        }
+        const videoPath = typeof videoSource === 'string' ? videoSource : path.join(frameDir, 'temp-video.mp4');
+        if (Buffer.isBuffer(videoSource)) {
+            fs.writeFileSync(videoPath, videoSource);
+        }
+        else if (videoSource.startsWith('http')) {
+            await axios({
+                method: 'get',
+                url: videoSource,
+                responseType: 'arraybuffer'
+            })
+                .then((response) => {
+                fs.writeFileSync(videoPath, response.data);
+            })
+                .catch(err => {
+                throw new Error(`Error downloading video: ${err.message}`);
+            });
+        }
+        else if (!fs.existsSync(videoPath)) {
+            throw new Error("Video file not found at specified path.");
+        }
+        function processVideoExtraction(videoPath, frames, options, resolve, reject) {
+            const outputFormat = options.outputFormat || 'jpg';
+            const outputFileTemplate = `frame-%03d.${outputFormat}`;
+            ffmpeg(videoPath)
+                .on('end', () => {
+                console.log('Frames extracted successfully.');
+                resolve(frames);
+            })
+                .on('error', (err) => {
+                console.error('Error extracting frames:', err.message);
+                reject(err);
+            })
+                .outputOptions([`-vf fps=1/${options.interval / 1000}`, `-q:v 2`]) // Set frame rate
+                .saveToFile(path.join(frameDir, outputFileTemplate)); // Save frames with a sequence number
+            ffmpeg.ffprobe(videoPath, (err, metadata) => {
+                if (err) {
+                    return reject(err);
+                }
+                const duration = metadata?.format?.duration;
+                if (duration === undefined) {
+                    return reject(new Error("Video duration not found in metadata."));
+                }
+                const totalFrames = Math.floor(duration * 1000 / options.interval);
+                for (let i = 0; i < totalFrames; i++) {
+                    if (options.frameSelection && (i < (options.frameSelection.start || 0) || i > (options.frameSelection.end || totalFrames - 1))) {
+                        continue;
+                    }
+                    frames.push({
+                        source: path.join(frameDir, `frame-${String(i).padStart(3, '0')}.${outputFormat}`),
+                        isRemote: false
+                    });
+                }
+            });
+        }
+        return new Promise((resolve, reject) => {
+            processVideoExtraction(videoPath, frames, options, resolve, reject);
+        });
+    }
+    /**
+     * Sets a pattern on a specific area of a buffered image.
+     * @param {Buffer} buffer - The source image buffer.
+     * @param {Object} options - Options to customize the pattern.
+     * @returns {Promise<Buffer>} - The adjusted image buffer.
+     */
+    async setPatternBackground(buffer, options) {
+        // Load the buffered image onto a canvas
+        const img = await loadImage(buffer);
+        const canvas = createCanvas(img.width, img.height);
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        // Set up the area to cover (default to full image if not specified)
+        const x = options.x || 0;
+        const y = options.y || 0;
+        const width = options.width || img.width;
+        const height = options.height || img.height;
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(x, y, width, height);
+        ctx.clip();
+        if (options.gradient) {
+            await this.fillWithGradient(ctx, width, height, options.gradient, x, y);
+        }
+        else if (options.backgroundColor) {
+            ctx.fillStyle = options.backgroundColor;
+            ctx.fillRect(x, y, width, height);
+        }
+        switch (options.type) {
+            case 'dots':
+                await this.drawDotsPattern(ctx, width, height, options, x, y);
+                break;
+            case 'stripes':
+                await this.drawStripesPattern(ctx, width, height, options, x, y);
+                break;
+            case 'grid':
+                await this.drawGridPattern(ctx, width, height, options, x, y);
+                break;
+            case 'checkerboard':
+                await this.drawCheckerboardPattern(ctx, width, height, options, x, y);
+                break;
+            case 'custom':
+                await this.drawCustomPattern(ctx, width, height, options, x, y);
+                break;
+            default:
+                throw new Error('Invalid pattern type specified.');
+        }
+        ctx.restore();
+        return canvas.toBuffer('image/png');
+    }
+    /**
+     * Fills the specified area with a gradient.
+     * @param ctx The rendering context of the canvas.
+     * @param width The width of the area to fill.
+     * @param height The height of the area to fill.
+     * @param gradient The gradient options.
+     * @param x The x offset of the area.
+     * @param y The y offset of the area.
+     */
+    async fillWithGradient(ctx, width, height, gradient, x = 0, y = 0) {
+        let grad;
+        if (gradient.type === 'linear') {
+            grad = ctx.createLinearGradient((gradient.startX || 0) + x, (gradient.startY || 0) + y, (gradient.endX || width) + x, (gradient.endY || height) + y);
+        }
+        else {
+            grad = ctx.createRadialGradient((gradient.startX || width / 2) + x, (gradient.startY || height / 2) + y, gradient.startRadius || 0, (gradient.endX || width / 2) + x, (gradient.endY || height / 2) + y, gradient.endRadius || Math.max(width, height));
+        }
+        gradient.colors.forEach(stop => {
+            grad.addColorStop(stop.stop, stop.color);
+        });
+        ctx.fillStyle = grad;
+        ctx.fillRect(x, y, width, height);
+    }
+    /**
+     * Draws a dots pattern in the specified area.
+     * @param ctx The rendering context of the canvas.
+     * @param width The width of the area.
+     * @param height The height of the area.
+     * @param options Options to customize the dot pattern.
+     * @param x The x offset of the area.
+     * @param y The y offset of the area.
+     */
+    async drawDotsPattern(ctx, width, height, options, x = 0, y = 0) {
+        const color = options.color || 'black';
+        const radius = options.size || 5;
+        const spacing = options.spacing || 10;
+        ctx.fillStyle = color;
+        for (let posY = y; posY < y + height; posY += spacing) {
+            for (let posX = x; posX < x + width; posX += spacing) {
+                ctx.beginPath();
+                ctx.arc(posX, posY, radius, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+    }
+    /**
+     * Draws a stripes pattern in the specified area.
+     * @param ctx The rendering context of the canvas.
+     * @param width The width of the area.
+     * @param height The height of the area.
+     * @param options Options to customize the stripes pattern.
+     * @param x The x offset of the area.
+     * @param y The y offset of the area.
+     */
+    async drawStripesPattern(ctx, width, height, options, x = 0, y = 0) {
+        const color = options.color || 'black';
+        const stripeWidth = options.size || 10;
+        const spacing = options.spacing || 20;
+        const angle = options.angle || 0;
+        ctx.fillStyle = color;
+        // Save the context to apply transformations and restore later
+        ctx.save();
+        // Translate and rotate the canvas
+        ctx.translate(x + width / 2, y + height / 2); // Move to the center of the area
+        ctx.rotate((angle * Math.PI) / 180); // Rotate by the specified angle
+        ctx.translate(-width / 2, -height / 2); // Translate back to top-left
+        // Draw the stripes pattern with the current transformations
+        for (let posX = 0; posX < width; posX += stripeWidth + spacing) {
+            ctx.fillRect(posX, 0, stripeWidth, height);
+        }
+        // Restore the original context to prevent transformations affecting other drawings
+        ctx.restore();
+    }
+    /**
+   * Draws a grid pattern in the specified area.
+   * @param ctx The rendering context of the canvas.
+   * @param width The width of the area.
+   * @param height The height of the area.
+   * @param options Options to customize the grid pattern.
+   * @param x The x offset of the area.
+   * @param y The y offset of the area.
+   */
+    async drawGridPattern(ctx, width, height, options, x = 0, y = 0) {
+        const color = options.color || 'black';
+        const size = options.size || 20;
+        ctx.strokeStyle = color;
+        ctx.lineWidth = 1;
+        for (let posX = x; posX <= x + width; posX += size) {
+            ctx.beginPath();
+            ctx.moveTo(posX, y);
+            ctx.lineTo(posX, y + height);
+            ctx.stroke();
+        }
+        for (let posY = y; posY <= y + height; posY += size) {
+            ctx.beginPath();
+            ctx.moveTo(x, posY);
+            ctx.lineTo(x + width, posY);
+            ctx.stroke();
+        }
+    }
+    /**
+     * Draws a checkerboard pattern in the specified area.
+     * @param ctx The rendering context of the canvas.
+     * @param width The width of the area.
+     * @param height The height of the area.
+     * @param options Options to customize the checkerboard pattern.
+     * @param x The x offset of the area.
+     * @param y The y offset of the area.
+     */
+    async drawCheckerboardPattern(ctx, width, height, options, x = 0, y = 0) {
+        const color1 = options.color || 'black';
+        const color2 = options.secondaryColor || 'white';
+        const size = options.size || 20;
+        for (let posY = y; posY < y + height; posY += size) {
+            for (let posX = x; posX < x + width; posX += size) {
+                ctx.fillStyle = (Math.floor(posX / size) + Math.floor(posY / size)) % 2 === 0 ? color1 : color2;
+                ctx.fillRect(posX, posY, size, size);
+            }
+        }
+    }
+    /**
+     * Draws a custom image pattern in the specified area.
+     * @param ctx The rendering context of the canvas.
+     * @param width The width of the area.
+     * @param height The height of the area.
+     * @param options Options to customize the custom pattern.
+     * @param x The x offset of the area.
+     * @param y The y offset of the area.
+     */
+    async drawCustomPattern(ctx, width, height, options, x = 0, y = 0) {
+        if (!options.customPatternImage) {
+            throw new Error('Custom pattern image path is required for custom patterns.');
+        }
+        const patternImage = await loadImage(options.customPatternImage);
+        const pattern = ctx.createPattern(patternImage, 'repeat');
+        ctx.fillStyle = pattern;
+        ctx.translate(x, y);
+        ctx.fillRect(0, 0, width, height);
+        ctx.resetTransform();
+    }
+    async animate(frames, defaultDuration, defaultWidth = 800, defaultHeight = 600, options) {
+        const buffers = [];
+        const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+        if (options?.onStart)
+            options.onStart();
+        let encoder = null;
+        let gifStream = null;
+        if (options?.gif) {
+            if (!options.gifPath) {
+                throw new Error("GIF generation enabled but no gifPath provided.");
+            }
+            encoder = new GIFEncoder(defaultWidth, defaultHeight);
+            gifStream = fs.createWriteStream(options.gifPath);
+            encoder.createReadStream().pipe(gifStream);
+            encoder.start();
+            encoder.setRepeat(0);
+            encoder.setQuality(10);
+        }
+        for (let i = 0; i < frames.length; i++) {
+            const frame = frames[i];
+            const width = frame.width || defaultWidth;
+            const height = frame.height || defaultHeight;
+            const canvas = createCanvas(width, height);
+            const ctx = canvas.getContext('2d');
+            if (!isNode) {
+                canvas.width = width;
+                canvas.height = height;
+                document.body.appendChild(canvas);
+            }
+            ctx.clearRect(0, 0, width, height);
+            if (frame.transformations) {
+                const { scaleX = 1, scaleY = 1, rotate = 0, translateX = 0, translateY = 0 } = frame.transformations;
+                ctx.save();
+                ctx.translate(translateX, translateY);
+                ctx.rotate((rotate * Math.PI) / 180);
+                ctx.scale(scaleX, scaleY);
+            }
+            let fillStyle = null;
+            if (frame.gradient) {
+                const { type, startX, startY, endX, endY, startRadius, endRadius, colors } = frame.gradient;
+                let gradient = null;
+                if (type === 'linear') {
+                    gradient = ctx.createLinearGradient(startX || 0, startY || 0, endX || width, endY || height);
+                }
+                else if (type === 'radial') {
+                    gradient = ctx.createRadialGradient(startX || width / 2, startY || height / 2, startRadius || 0, endX || width / 2, endY || height / 2, endRadius || Math.max(width, height));
+                }
+                colors.forEach(colorStop => {
+                    if (gradient)
+                        gradient.addColorStop(colorStop.stop, colorStop.color);
+                });
+                fillStyle = gradient;
+            }
+            if (frame.pattern) {
+                const patternImage = await loadImage(frame.pattern.imagePath);
+                const pattern = ctx.createPattern(patternImage, frame.pattern.repeat || 'repeat');
+                fillStyle = pattern;
+            }
+            if (!fillStyle && frame.backgroundColor) {
+                fillStyle = frame.backgroundColor;
+            }
+            if (fillStyle) {
+                ctx.fillStyle = fillStyle;
+                ctx.fillRect(0, 0, width, height);
+            }
+            if (frame.imagePath) {
+                const image = await loadImage(frame.imagePath);
+                ctx.globalCompositeOperation = frame.blendMode || 'source-over';
+                ctx.drawImage(image, 0, 0, width, height);
+            }
+            if (frame.onDrawCustom) {
+                frame.onDrawCustom(ctx, canvas);
+            }
+            if (frame.transformations) {
+                ctx.restore();
+            }
+            const buffer = canvas.toBuffer('image/png');
+            buffers.push(buffer);
+            if (encoder) {
+                const frameDuration = frame.duration || defaultDuration;
+                encoder.setDelay(frameDuration);
+                encoder.addFrame(ctx);
+            }
+            if (options?.onFrame)
+                options.onFrame(i);
+            await new Promise(resolve => setTimeout(resolve, frame.duration || defaultDuration));
+        }
+        if (encoder) {
+            encoder.finish();
+        }
+        if (options?.onEnd)
+            options.onEnd();
+        return options?.gif ? undefined : buffers;
+    }
+    validHex(hexColor) {
+        const hexPattern = /^#[0-9a-fA-F]{6}$/;
+        if (!hexPattern.test(hexColor)) {
+            throw new Error("Invalid hexadecimal color format. It should be in the format '#RRGGBB'.");
+        }
+        return true;
+    }
+    async outPut(results) {
+        const formatType = this.format?.type || 'buffer';
+        switch (formatType) {
+            case 'buffer':
+                return results;
+            case 'url':
+                return await url(results);
+            case 'dataURL':
+                return dataURL(results);
+            case 'blob':
+                return blob(results);
+            case 'base64':
+                return base64(results);
+            case 'arraybuffer':
+                return arrayBuffer(results);
+            default:
+                throw new Error('Unsupported format');
+        }
+    }
+}
+//# sourceMappingURL=ApexPainter.js.map