apexify.js 4.8.3 → 4.8.4

package/dist/esm/canvas/ApexPainter.js

@@ -0,0 +1,908 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApexPainter = void 0;
+const canvas_1 = require("@napi-rs/canvas");
+const gifencoder_1 = __importDefault(require("gifencoder"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const stream_1 = require("stream");
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils/utils");
+class ApexPainter {
+    format;
+    constructor({ type } = { type: 'buffer' }) {
+        this.format = { type: type || 'buffer' };
+    }
+    /**
+     * Creates a canvas with the given configuration.
+     * Applies rotation, shadow, border effects, background, and stroke.
+     *
+     * @param canvas - The configuration options for the canvas.
+     * @returns A promise that resolves to an object containing the image buffer and the canvas config.
+     * @throws If the 2D context cannot be retrieved.
+     */
+    async createCanvas(canvas) {
+        const { width = 500, height = 500, x = 0, y = 0, rotation = 0, borderRadius = 0, customBg, gradientBg, stroke, shadow, borderPosition = 'all', opacity = 1, zoom, blur } = canvas;
+        const canvasInstance = (0, canvas_1.createCanvas)(width, height);
+        const ctx = canvasInstance.getContext('2d');
+        if (!ctx) {
+            throw new Error('Unable to get 2D rendering context from canvas');
+        }
+        ctx.globalAlpha = opacity;
+        (0, utils_1.applyRotation)(ctx, rotation, x, y, width, height);
+        (0, utils_1.applyShadow)(ctx, shadow, x, y, width, height);
+        ctx.save();
+        if (borderRadius) {
+            (0, utils_1.backgroundRadius)(ctx, x, y, width, height, borderRadius, borderPosition);
+        }
+        ctx.translate(x, y);
+        if (customBg) {
+            await (0, utils_1.customBackground)(ctx, canvas, zoom, blur);
+        }
+        else if (gradientBg) {
+            await (0, utils_1.drawBackgroundGradient)(ctx, canvas, zoom, blur);
+        }
+        else {
+            await (0, utils_1.drawBackgroundColor)(ctx, canvas, zoom, blur);
+        }
+        ctx.restore();
+        (0, utils_1.applyStroke)(ctx, stroke, x, y, width, height);
+        return { buffer: canvasInstance.toBuffer('image/png'), canvas };
+    }
+    /**
+     * Draws one or more images (or shapes) on an existing canvas buffer.
+     * @param images - A single image properties object or an array of them.
+     * @param canvasBuffer - A Buffer or a CanvasResults object containing a buffer.
+     * @returns A promise that resolves to a Buffer representing the updated canvas.
+     */
+    async createImage(images, canvasBuffer) {
+        if (!Array.isArray(images)) {
+            images = [images];
+        }
+        let baseImage;
+        if (Buffer.isBuffer(canvasBuffer)) {
+            baseImage = await (0, canvas_1.loadImage)(canvasBuffer);
+        }
+        else if (canvasBuffer.buffer) {
+            baseImage = await (0, canvas_1.loadImage)(canvasBuffer.buffer);
+        }
+        else {
+            throw new Error('Invalid canvasBuffer provided; expected Buffer or CanvasResults with a buffer');
+        }
+        if (!baseImage) {
+            throw new Error('Unable to load base image from the provided buffer');
+        }
+        const canvas = (0, canvas_1.createCanvas)(baseImage.width, baseImage.height);
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Unable to get 2D rendering context from canvas');
+        }
+        ctx.drawImage(baseImage, 0, 0);
+        for (const imageProps of images) {
+            await this.drawImage(ctx, imageProps);
+        }
+        return canvas.toBuffer('image/png');
+    }
+    async createText(textOptionsArray, buffer) {
+        try {
+            if (!Array.isArray(textOptionsArray)) {
+                textOptionsArray = [textOptionsArray];
+            }
+            let existingImage;
+            if (Buffer.isBuffer(buffer)) {
+                existingImage = await (0, canvas_1.loadImage)(buffer);
+            }
+            else if (buffer && buffer.buffer) {
+                existingImage = await (0, canvas_1.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 = (0, canvas_1.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) {
+                    canvas_1.GlobalFonts.registerFromPath(path_1.default.join(process.cwd(), mergedTextOptions.fontPath), (mergedTextOptions.fontName || 'customFont'));
+                }
+                (0, utils_1.drawText)(ctx, mergedTextOptions);
+            }
+            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 (0, canvas_1.loadImage)(buffer);
+            }
+            else if (buffer && buffer.buffer) {
+                existingImage = await (0, canvas_1.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 = (0, canvas_1.createCanvas)(existingImage.width, existingImage.height);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(existingImage, 0, 0);
+            (0, utils_1.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 = (0, canvas_1.createCanvas)(targetWidth, targetHeight);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(image, 0, 0, targetWidth, targetHeight);
+            return canvas;
+        }
+        function createOutputStream(outputFile) {
+            return fs_1.default.createWriteStream(outputFile);
+        }
+        function createBufferStream() {
+            const bufferStream = new stream_1.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_1.default(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 = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
+            const ctx = canvas.getContext("2d");
+            for (const frame of gifFrames) {
+                const image = await (0, canvas_1.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 (0, canvas_1.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;
+        }
+    }
+    async resize(resizeOptions) {
+        return (0, utils_1.resizingImg)(resizeOptions);
+    }
+    async imgConverter(source, newExtension) {
+        return (0, utils_1.converter)(source, newExtension);
+    }
+    async effects(source, filters) {
+        return (0, utils_1.imgEffects)(source, filters);
+    }
+    async colorsFilter(source, filterColor, opacity) {
+        return (0, utils_1.applyColorFilters)(source, filterColor, opacity);
+    }
+    async colorAnalysis(source) {
+        return (0, utils_1.detectColors)(source);
+    }
+    async colorsRemover(source, colorToRemove) {
+        return (0, utils_1.removeColor)(source, colorToRemove);
+    }
+    async removeBackground(imageURL, apiKey) {
+        return (0, utils_1.bgRemoval)(imageURL, apiKey);
+    }
+    async blend(layers, baseImageBuffer, defaultBlendMode = 'source-over') {
+        try {
+            const baseImage = await (0, canvas_1.loadImage)(baseImageBuffer);
+            const canvas = (0, canvas_1.createCanvas)(baseImage.width, baseImage.height);
+            const ctx = canvas.getContext('2d');
+            ctx.globalCompositeOperation = defaultBlendMode;
+            ctx.drawImage(baseImage, 0, 0);
+            for (const layer of layers) {
+                const layerImage = await (0, canvas_1.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 = defaultBlendMode; // Reset to user-defined default
+            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 (0, utils_1.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 (0, utils_1.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 (0, utils_1.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 (0, utils_1.cropOuter)(options);
+            }
+            else if (options.crop === 'inner') {
+                return await (0, utils_1.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 = 0, borderRadius = 0, stroke, shadow, isFilled, color, gradient, borderPosition = 'all', opacity, perspective, blur = 0, zoom, filling } = image;
+        if (perspective)
+            throw new Error("`perspective` Feature is under construction. Please refrain from using it.");
+        if (!source || typeof x !== 'number' || typeof y !== 'number' || typeof width !== 'number' || typeof height !== 'number') {
+            throw new Error('Invalid image properties: source, x, y, width, and height are required.');
+        }
+        const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite', 'arrow', 'star', 'oval', 'heart', 'diamond', 'trapezoid', 'cloud'];
+        const isShape = shapeNames.includes(source.toLowerCase());
+        if (isShape) {
+            (0, utils_1.drawShape)(ctx, { source, x, y, width, height, opacity, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition, filling });
+            return;
+        }
+        let loadedImage;
+        try {
+            if (source.startsWith('http')) {
+                loadedImage = await (0, canvas_1.loadImage)(source);
+            }
+            else {
+                const imagePath = path_1.default.resolve(process.cwd(), source);
+                loadedImage = await (0, canvas_1.loadImage)(imagePath);
+            }
+        }
+        catch (e) {
+            throw new Error(`Error loading image: ${e.message}`);
+        }
+        if (!loadedImage) {
+            throw new Error('Invalid image source or failed to load image');
+        }
+        ctx.save();
+        const scale = zoom?.scale ?? 1;
+        const focusX = zoom?.x ?? 0.5;
+        const focusY = zoom?.y ?? 0.5;
+        if (scale !== 1) {
+            ctx.translate(focusX, focusY);
+            ctx.scale(scale, scale);
+        }
+        if (opacity !== undefined) {
+            ctx.globalAlpha = opacity;
+        }
+        if (blur > 0) {
+            ctx.filter = `blur(${blur}px)`;
+        }
+        (0, utils_1.applyRotation)(ctx, rotation, x, y, width, height);
+        (0, utils_1.applyShadow)(ctx, shadow, x, y, width, height);
+        if (perspective) {
+            throw new Error('Under construction');
+        }
+        (0, utils_1.imageRadius)(ctx, loadedImage, x, y, width, height, borderRadius, borderPosition);
+        ctx.globalAlpha = 1.0;
+        if (stroke?.opacity)
+            ctx.globalAlpha = stroke.opacity;
+        (0, utils_1.applyStroke)(ctx, stroke, x, y, width, height, undefined);
+        ctx.globalAlpha = 1.0;
+        ctx.restore();
+    }
+    async extractFrames(videoSource, options) {
+        const frames = [];
+        const frameDir = path_1.default.join(__dirname, 'frames');
+        if (!fs_1.default.existsSync(frameDir)) {
+            fs_1.default.mkdirSync(frameDir);
+        }
+        const videoPath = typeof videoSource === 'string' ? videoSource : path_1.default.join(frameDir, 'temp-video.mp4');
+        if (Buffer.isBuffer(videoSource)) {
+            fs_1.default.writeFileSync(videoPath, videoSource);
+        }
+        else if (videoSource.startsWith('http')) {
+            await (0, axios_1.default)({
+                method: 'get',
+                url: videoSource,
+                responseType: 'arraybuffer'
+            })
+                .then((response) => {
+                fs_1.default.writeFileSync(videoPath, response.data);
+            })
+                .catch(err => {
+                throw new Error(`Error downloading video: ${err.message}`);
+            });
+        }
+        else if (!fs_1.default.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}`;
+            (0, fluent_ffmpeg_1.default)(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`])
+                .saveToFile(path_1.default.join(frameDir, outputFileTemplate));
+            fluent_ffmpeg_1.default.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_1.default.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 patterns(buffer, options) {
+        const img = await (0, canvas_1.loadImage)(buffer);
+        const canvas = (0, canvas_1.createCanvas)(img.width, img.height);
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+        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;
+            case 'noise':
+                await this.drawNoisePattern(ctx, width, height, x, y);
+                break;
+            case 'waves':
+                await this.drawWavePattern(ctx, width, height, options, x, y);
+                break;
+            case 'diagonal-checkerboard':
+                await this.drawDiagonalCheckerboardPattern(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;
+        ctx.save();
+        ctx.translate(x + width / 2, y + height / 2);
+        ctx.rotate((angle * Math.PI) / 180);
+        ctx.translate(-width / 2, -height / 2);
+        for (let posX = 0; posX < width; posX += stripeWidth + spacing) {
+            ctx.fillRect(posX, 0, stripeWidth, height);
+        }
+        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 (0, canvas_1.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 drawWavePattern(ctx, width, height, options, x = 0, y = 0) {
+        const color = options.color || 'black';
+        const waveHeight = options.size || 10;
+        const frequency = options.spacing || 20;
+        ctx.strokeStyle = color;
+        ctx.lineWidth = 2;
+        for (let posY = y; posY < y + height; posY += frequency) {
+            ctx.beginPath();
+            for (let posX = x; posX < x + width; posX += 5) {
+                const waveY = posY + Math.sin(posX / frequency) * waveHeight;
+                ctx.lineTo(posX, waveY);
+            }
+            ctx.stroke();
+        }
+    }
+    async drawNoisePattern(ctx, width, height, x = 0, y = 0) {
+        const imageData = ctx.createImageData(width, height);
+        const data = imageData.data;
+        for (let i = 0; i < data.length; i += 4) {
+            const gray = Math.random() * 255;
+            data[i] = gray;
+            data[i + 1] = gray;
+            data[i + 2] = gray;
+            data[i + 3] = Math.random() * 255;
+        }
+        ctx.putImageData(imageData, x, y);
+    }
+    async drawDiagonalCheckerboardPattern(ctx, width, height, options, x = 0, y = 0) {
+        const color1 = options.color || 'black';
+        const color2 = options.secondaryColor || 'white';
+        const size = options.size || 20;
+        ctx.save();
+        ctx.translate(x + width / 2, y + height / 2);
+        ctx.rotate(Math.PI / 4);
+        ctx.translate(-width / 2, -height / 2);
+        for (let posY = 0; posY < height; posY += size) {
+            for (let posX = 0; posX < width; posX += size) {
+                ctx.fillStyle = (Math.floor(posX / size) + Math.floor(posY / size)) % 2 === 0 ? color1 : color2;
+                ctx.fillRect(posX, posY, size, size);
+            }
+        }
+        ctx.restore();
+    }
+    async masking(source, maskSource, options = { type: "alpha" }) {
+        const img = await (0, canvas_1.loadImage)(source);
+        const mask = await (0, canvas_1.loadImage)(maskSource);
+        const canvas = (0, canvas_1.createCanvas)(img.width, img.height);
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(img, 0, 0, img.width, img.height);
+        const maskCanvas = (0, canvas_1.createCanvas)(img.width, img.height);
+        const maskCtx = maskCanvas.getContext("2d");
+        maskCtx.drawImage(mask, 0, 0, img.width, img.height);
+        const maskData = maskCtx.getImageData(0, 0, img.width, img.height);
+        const imgData = ctx.getImageData(0, 0, img.width, img.height);
+        for (let i = 0; i < maskData.data.length; i += 4) {
+            let alphaValue = 255;
+            if (options.type === "grayscale") {
+                const grayscale = maskData.data[i] * 0.3 + maskData.data[i + 1] * 0.59 + maskData.data[i + 2] * 0.11;
+                alphaValue = grayscale >= (options.threshold ?? 128) ? 255 : 0;
+            }
+            else if (options.type === "alpha") {
+                alphaValue = maskData.data[i + 3];
+            }
+            else if (options.type === "color" && options.colorKey) {
+                const colorMatch = maskData.data[i] === parseInt(options.colorKey.slice(1, 3), 16) &&
+                    maskData.data[i + 1] === parseInt(options.colorKey.slice(3, 5), 16) &&
+                    maskData.data[i + 2] === parseInt(options.colorKey.slice(5, 7), 16);
+                alphaValue = colorMatch ? 0 : 255;
+            }
+            if (options.invert)
+                alphaValue = 255 - alphaValue;
+            imgData.data[i + 3] = alphaValue;
+        }
+        ctx.putImageData(imgData, 0, 0);
+        return canvas.toBuffer("image/png");
+    }
+    async gradientBlend(source, options) {
+        const img = await (0, canvas_1.loadImage)(source);
+        const canvas = (0, canvas_1.createCanvas)(img.width, img.height);
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(img, 0, 0, img.width, img.height);
+        let gradient;
+        if (options.type === "linear") {
+            const angle = options.angle ?? 0;
+            const radians = (angle * Math.PI) / 180;
+            const x1 = img.width / 2 - (Math.cos(radians) * img.width) / 2;
+            const y1 = img.height / 2 - (Math.sin(radians) * img.height) / 2;
+            const x2 = img.width / 2 + (Math.cos(radians) * img.width) / 2;
+            const y2 = img.height / 2 + (Math.sin(radians) * img.height) / 2;
+            gradient = ctx.createLinearGradient(x1, y1, x2, y2);
+        }
+        else if (options.type === "radial") {
+            gradient = ctx.createRadialGradient(img.width / 2, img.height / 2, 0, img.width / 2, img.height / 2, Math.max(img.width, img.height));
+        }
+        else {
+            gradient = ctx.createConicGradient(Math.PI, img.width / 2, img.height / 2);
+        }
+        options.colors.forEach(({ stop, color }) => gradient.addColorStop(stop, color));
+        ctx.fillStyle = gradient;
+        ctx.globalCompositeOperation = options.blendMode ?? "multiply";
+        ctx.fillRect(0, 0, img.width, img.height);
+        if (options.maskSource) {
+            const mask = await (0, canvas_1.loadImage)(options.maskSource);
+            ctx.globalCompositeOperation = "destination-in";
+            ctx.drawImage(mask, 0, 0, img.width, img.height);
+        }
+        ctx.globalCompositeOperation = "source-over";
+        return canvas.toBuffer("image/png");
+    }
+    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_1.default(defaultWidth, defaultHeight);
+            gifStream = fs_1.default.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 = (0, canvas_1.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 (0, canvas_1.loadImage)(frame.pattern.source);
+                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.source) {
+                const image = await (0, canvas_1.loadImage)(frame.source);
+                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 (0, utils_1.url)(results);
+            case 'dataURL':
+                return (0, utils_1.dataURL)(results);
+            case 'blob':
+                return (0, utils_1.blob)(results);
+            case 'base64':
+                return (0, utils_1.base64)(results);
+            case 'arraybuffer':
+                return (0, utils_1.arrayBuffer)(results);
+            default:
+                throw new Error('Unsupported format');
+        }
+    }
+}
+exports.ApexPainter = ApexPainter;
+//# sourceMappingURL=ApexPainter.js.map