apexify.js 3.0.2 → 3.1.0

package/lib/canvas/ApexPainter.js

@@ -1,1396 +0,0 @@
-const { createCanvas, loadImage, GlobalFonts } = require("@napi-rs/canvas");
-const path = require("path");
-const axios = require("axios");
-const sharp = require("sharp");
-const fs = require("fs");
-const Jimp = require("jimp");
-const FormData = require("form-data");
-const GIFEncoder = require("gifencoder");
-const stream = require("stream");
-
-class ApexPainter {
-  constructor() {
-    this.defaultTextOptions = {
-      text: "Add Text Here",
-      x: 50,
-      y: 50,
-      fontPath: null,
-      fontName: "Arial",
-      fontSize: 20,
-      color: "black",
-      maxWidth: null,
-      lineHeight: null,
-      textAlign: "left",
-      textBaseline: "top",
-      shadow: {
-        color: null,
-        offsetX: 0,
-        offsetY: 0,
-        blur: 0,
-        opacity: 0,
-      },
-      stroke: {
-        color: null,
-        width: 0,
-      },
-    };
-
-    this.frames = [];
-
-    this.defaultImageOptions = {
-      source: null,
-      x: 0,
-      y: 0,
-      width: null,
-      height: null,
-      filled: null,
-      borderRadius: null,
-      color: null,
-      gradient: null,
-      rotate: null,
-      shadow: {
-        color: null,
-        offsetX: 0,
-        offsetY: 0,
-        opacity: 0,
-        blur: 0,
-        borderRadius: null,
-      },
-      stroke: {
-        color: null,
-        width: null,
-        borderRadius: null,
-      },
-    };
-
-    this.defaultCanvasOptions = {
-      width: 500,
-      height: 300,
-      x: 0,
-      y: 0,
-      backgroundColor: null,
-      borderRadius: null,
-      backgroundGradient: null,
-      customBg: null,
-    };
-  }
-
-  validateCanvasOptions(canvasOptions) {
-    if (!canvasOptions || typeof canvasOptions !== "object") {
-      throw new Error(
-        "Invalid canvas options. Provide a valid object for canvas configuration.",
-      );
-    }
-
-    if (
-      typeof canvasOptions.width !== "number" ||
-      typeof canvasOptions.height !== "number"
-    ) {
-      throw new Error("Canvas width and height must be numbers.");
-    }
-
-    if (canvasOptions.width <= 0 || canvasOptions.height <= 0) {
-      throw new Error("Canvas width and height must be positive values.");
-    }
-
-    return true;
-  }
-
-  validateFrameOptions(frame) {
-    if (!frame || typeof frame !== "object") {
-      throw new Error(
-        "Invalid frame options. Provide a valid object for frame configuration.",
-      );
-    }
-
-    if (typeof frame.delay !== "number" || frame.delay < 0) {
-      throw new Error("Frame delay must be a non-negative number.");
-    }
-
-    if (
-      typeof frame.quality !== "number" ||
-      frame.quality < 1 ||
-      frame.quality > 100
-    ) {
-      throw new Error("Frame quality must be a number between 1 and 100.");
-    }
-
-    if (typeof frame.loop !== "number" || frame.loop < 0) {
-      throw new Error("Frame loop count must be a non-negative number.");
-    }
-
-    return true;
-  }
-
-  validateImageOptions(imageOptions) {
-    if (!imageOptions || typeof imageOptions !== "object") {
-      throw new Error(
-        "Invalid image options. Provide a valid object for image configuration.",
-      );
-    }
-
-    if (!imageOptions.source) {
-      throw new Error("Image source is required.");
-    }
-
-    if (
-      typeof imageOptions.x !== "number" ||
-      typeof imageOptions.y !== "number"
-    ) {
-      throw new Error("Image x and y coordinates must be numbers.");
-    }
-
-    if (
-      imageOptions.width &&
-      (typeof imageOptions.width !== "number" || imageOptions.width <= 0)
-    ) {
-      throw new Error("Image width must be a positive number.");
-    }
-
-    if (
-      imageOptions.height &&
-      (typeof imageOptions.height !== "number" || imageOptions.height <= 0)
-    ) {
-      throw new Error("Image height must be a positive number.");
-    }
-    return true;
-  }
-
-  validateTextOptions(textOptions) {
-    if (!textOptions || typeof textOptions !== "object") {
-      throw new Error(
-        "Invalid text options. Provide a valid object for text configuration.",
-      );
-    }
-    if (
-      typeof textOptions.x !== "number" ||
-      typeof textOptions.y !== "number"
-    ) {
-      throw new Error("Text x and y coordinates must be numbers.");
-    }
-
-    if (
-      textOptions.fontSize &&
-      (typeof textOptions.fontSize !== "number" || textOptions.fontSize <= 0)
-    ) {
-      throw new Error("Text fontSize must be a positive number.");
-    }
-
-    return true;
-  }
-
-  async drawImages(imagesOptions, canvasOptions, baseDir) {
-    const mergedCanvasOptions = this.mergeOptions(
-      this.defaultCanvasOptions,
-      canvasOptions,
-    );
-
-    if (!mergedCanvasOptions || typeof mergedCanvasOptions !== "object") {
-      throw new Error(
-        "Invalid canvas options. Provide a valid object for canvas configuration.",
-      );
-    }
-
-    if (
-      typeof mergedCanvasOptions.width !== "number" ||
-      typeof mergedCanvasOptions.height !== "number"
-    ) {
-      throw new Error("Canvas width and height must be numbers.");
-    }
-
-    if (mergedCanvasOptions.width <= 0 || mergedCanvasOptions.height <= 0) {
-      throw new Error("Canvas width and height must be positive values.");
-    }
-
-    let canvas;
-    let ctx;
-
-    if (mergedCanvasOptions.customBg) {
-
-      if (typeof mergedCanvasOptions.customBg !== 'string' || !mergedCanvasOptions.customBg.startsWith('http')) {
-  throw new Error('Invalid customBg URL');
-}
-
-const customBgImage = await loadImage(mergedCanvasOptions.customBg);
-canvas = createCanvas(customBgImage.width, customBgImage.height);
-ctx = canvas.getContext("2d");
-
-this.drawRoundedRect(
-  ctx,
-  mergedCanvasOptions.x,
-  mergedCanvasOptions.y,
-  mergedCanvasOptions.width,
-  mergedCanvasOptions.height,
-  mergedCanvasOptions.borderRadius,
-);
-
-ctx.clip();
-
-ctx.drawImage(customBgImage, 0, 0);
-    } else {
-      canvas = createCanvas(
-        mergedCanvasOptions.width,
-        mergedCanvasOptions.height,
-      );
-      ctx = canvas.getContext("2d");
-
-      if (mergedCanvasOptions.backgroundGradient) {
-        const gradient = this.createGradient(
-          ctx,
-          mergedCanvasOptions.backgroundGradient,
-          mergedCanvasOptions.x,
-          mergedCanvasOptions.y,
-          mergedCanvasOptions.width,
-          mergedCanvasOptions.height,
-        );
-        ctx.fillStyle = gradient;
-        this.drawRoundedRect(
-          ctx,
-          mergedCanvasOptions.x,
-          mergedCanvasOptions.y,
-          mergedCanvasOptions.width,
-          mergedCanvasOptions.height,
-          mergedCanvasOptions.borderRadius,
-        );
-        ctx.fill();
-      } else if (mergedCanvasOptions.backgroundColor) {
-        if (mergedCanvasOptions.borderRadius) {
-          this.drawRoundedRect(
-            ctx,
-            mergedCanvasOptions.x,
-            mergedCanvasOptions.y,
-            mergedCanvasOptions.width,
-            mergedCanvasOptions.height,
-            mergedCanvasOptions.borderRadius,
-          );
-          ctx.fillStyle = mergedCanvasOptions.backgroundColor;
-          ctx.fill();
-        } else {
-          ctx.fillStyle = mergedCanvasOptions.backgroundColor;
-          ctx.fillRect(
-            mergedCanvasOptions.x,
-            mergedCanvasOptions.y,
-            mergedCanvasOptions.width,
-            mergedCanvasOptions.height,
-          );
-        }
-      }
-    }
-
-    if (imagesOptions && imagesOptions.length > 0) {
-      for (const imageOptions of imagesOptions) {
-        await this.drawSingleImage(ctx, imageOptions, baseDir);
-      }
-    }
-
-    return canvas.toBuffer("image/png");
-  }
-
-  async drawSingleImage(ctx, imageOptions, baseDir) {
-    const mergedImageOptions = this.mergeOptions(
-      this.defaultImageOptions,
-      imageOptions,
-    );
-    this.validateImageOptions(imageOptions);
-
-    if (
-      mergedImageOptions.source &&
-      this.isShapeName(mergedImageOptions.source)
-    ) {
-      this.drawShape(ctx, mergedImageOptions);
-      return;
-    }
-
-    if (mergedImageOptions.source) {
-      let image;
-
-      if (baseDir) {
-        const imagePath = path.join(baseDir, mergedImageOptions.source);
-
-        if (
-          mergedImageOptions.source.startsWith("http") ||
-          mergedImageOptions.source.startsWith("https")
-        ) {
-          image = await loadImage(mergedImageOptions.source);
-        } else {
-          image = await loadImage(imagePath);
-        }
-      } else {
-        if (
-          mergedImageOptions.source.startsWith("http") ||
-          mergedImageOptions.source.startsWith("https")
-        ) {
-          image = await loadImage(mergedImageOptions.source);
-        } else {
-          image = await loadImage(mergedImageOptions.source);
-        }
-      }
-
-      ctx.save();
-
-      if (
-        mergedImageOptions.shadow &&
-        mergedImageOptions.shadow.offsetX &&
-        mergedImageOptions.shadow.offsetY
-      ) {
-        ctx.globalAlpha = mergedImageOptions.shadow.opacity || null;
-        ctx.filter = `blur(${mergedImageOptions.shadow.blur || null}px)`;
-
-        const shadowX =
-          mergedImageOptions.x + (mergedImageOptions.shadow.offsetX || 0);
-        const shadowY =
-          mergedImageOptions.y + (mergedImageOptions.shadow.offsetY || 0);
-
-        this.drawRoundedRect(
-          ctx,
-          shadowX,
-          shadowY,
-          mergedImageOptions.width,
-          mergedImageOptions.height,
-          mergedImageOptions.shadow.borderRadius || 0,
-        );
-
-        ctx.fillStyle = mergedImageOptions.shadow.color || "transparent";
-        ctx.fill();
-      }
-
-      ctx.filter = "none";
-      ctx.globalAlpha = 1;
-
-      this.drawRoundedImage(
-        ctx,
-        image,
-        mergedImageOptions.x,
-        mergedImageOptions.y,
-        mergedImageOptions.width,
-        mergedImageOptions.height,
-        mergedImageOptions.borderRadius || 0,
-      );
-
-      ctx.restore();
-
-      if (
-        mergedImageOptions.stroke &&
-        mergedImageOptions.stroke.color &&
-        mergedImageOptions.stroke.width
-      ) {
-        ctx.strokeStyle = mergedImageOptions.stroke.color || "transparent"; // Change color as needed
-        ctx.lineWidth = mergedImageOptions.stroke.width || 1;
-
-        this.drawRoundedRect(
-          ctx,
-          mergedImageOptions.x,
-          mergedImageOptions.y,
-          mergedImageOptions.width,
-          mergedImageOptions.height,
-          mergedImageOptions.stroke.borderRadius || 0,
-        );
-        ctx.stroke();
-      }
-      ctx.restore();
-    }
-  }
-
-  isShapeName(source) {
-    
-    const validShapes = ["square", "circle", "triangle", "rectangle"];
-    return validShapes.includes(source?.toLowerCase() || 'square');
-  }
-
-  drawShape(ctx, shapeOptions, canvasBackgroundColor) {
-    const {
-      source,
-      x,
-      y,
-      width,
-      height,
-      borderRadius,
-      stroke,
-      color,
-      rotate,
-      filled,
-      gradient,
-      shadow,
-    } = shapeOptions;
-    const isFilled = filled !== undefined ? filled : true;
-
-    ctx.save();
-
-    if (shadow && shadow.offsetX && shadow.offsetY) {
-      ctx.globalAlpha = shadow.opacity || null;
-      ctx.filter = `blur(${shadow.blur || null}px)`;
-
-      const shadowX = x + (shadow.offsetX || 0);
-      const shadowY = y + (shadow.offsetY || 0);
-
-      this.drawRoundedRect(
-        ctx,
-        shadowX,
-        shadowY,
-        width,
-        height,
-        shadow.borderRadius || 0,
-      );
-
-      ctx.fillStyle = shadow.color || "transparent";
-      ctx.fill();
-    }
-
-    ctx.filter = "none";
-    ctx.globalAlpha = 1;
-
-    if (rotate) {
-      const centerX = x + width / 2;
-      const centerY = y + height / 2;
-      ctx.translate(centerX, centerY);
-      ctx.rotate((rotate * Math.PI) / 180);
-      ctx.translate(-centerX, -centerY);
-    }
-
-    if (gradient) {
-      const gradientFill = this.createGradient(
-        ctx,
-        gradient,
-        x,
-        y,
-        x + width,
-        y + height,
-      );
-      ctx.fillStyle = gradientFill;
-    } else {
-      ctx.fillStyle = color || "transparent";
-    }
-
-    ctx.beginPath();
-
-    switch (source.toLowerCase()) {
-      case "square":
-        this.drawRoundedRect(ctx, x, y, width, height, borderRadius || 0);
-        break;
-      case "circle":
-        const circleRadius = Math.min(width, height) / 2;
-        ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
-        break;
-      case "triangle":
-        ctx.moveTo(x + width / 2, y);
-        ctx.lineTo(x + width, y + height);
-        ctx.lineTo(x, y + height);
-        ctx.closePath();
-        break;
-      case "pentagon":
-        const sideLength = Math.min(width, height);
-        for (let i = 0; i < 5; i++) {
-          const angle = (i * 2 * Math.PI) / 5;
-          const px = x + width / 2 + sideLength * Math.cos(angle);
-          const py = y + height / 2 + sideLength * Math.sin(angle);
-          if (i === 0) {
-            ctx.moveTo(px, py);
-          } else {
-            ctx.lineTo(px, py);
-          }
-        }
-        ctx.closePath();
-        break;
-      default:
-        console.error(`Unsupported shape: ${source}`);
-    }
-
-    if (isFilled) {
-      ctx.fill();
-    } else {
-      ctx.stroke();
-    }
-
-    ctx.restore();
-
-    if (stroke && stroke.color !== undefined && stroke.width !== undefined) {
-      ctx.strokeStyle = stroke.color || "transparent";
-      ctx.lineWidth = stroke.width || 1;
-      ctx.save();
-
-      if (rotate) {
-        const centerX = x + width / 2;
-        const centerY = y + height / 2;
-        ctx.translate(centerX, centerY);
-        ctx.rotate((rotate * Math.PI) / 180);
-        ctx.translate(-centerX, -centerY);
-      }
-
-      ctx.fillStyle = "transparent";
-      this.drawRoundedRect(
-        ctx,
-        x,
-        y,
-        width,
-        height,
-        stroke.borderRadius || 0,
-        isFilled,
-      );
-      ctx.stroke();
-
-      ctx.restore();
-    }
-
-    ctx.restore();
-  }
-
-  async addText(textOptionsArray, buffer, baseDir) {
-    try {
-
-      const existingImage = await loadImage(buffer);
-      const canvas = createCanvas(existingImage.width, existingImage.height);
-      const ctx = canvas.getContext("2d");
-
-      ctx.drawImage(existingImage, 0, 0);
-
-      for (const textOptions of textOptionsArray) {
-        this.validateTextOptions(textOptions);
-
-        const mergedTextOptions = this.mergeOptions(
-          this.defaultTextOptions,
-          textOptions,
-        );
-
-        if (mergedTextOptions.fontPath) {
-          if (!baseDir)
-            throw new Error("You need to mention __dirname in the textOptions");
-          GlobalFonts.registerFromPath(
-            path.join(baseDir, mergedTextOptions.fontPath),
-            mergedTextOptions.fontName,
-          );
-          ctx.font = `${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName || "Arial"}`;
-        } else {
-          ctx.font = `${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName || "Arial"}`;
-        }
-
-        this.drawText(ctx, mergedTextOptions);
-      }
-
-      return canvas.toBuffer("image/png");
-    } catch (error) {
-      console.error("Error loading existing image:", error);
-      throw new Error("Invalid image buffer");
-    }
-  }
-
-  drawText(ctx, textOptions) {
-    const mergedTextOptions = this.mergeOptions(
-      this.defaultTextOptions,
-      textOptions,
-    );
-
-    ctx.save();
-    let boldness = '';
-    if (mergedTextOptions.bold) {
-      boldness = 'bold';
-    }
-    ctx.font = `${boldness}${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName}`;
-    ctx.textAlign = mergedTextOptions.textAlign;
-    ctx.textBaseline = mergedTextOptions.textBaseline;
-
-    if (
-      mergedTextOptions.shadow &&
-      mergedTextOptions.shadow.offsetX !== undefined &&
-      mergedTextOptions.shadow.offsetY !== undefined
-    ) {
-      ctx.shadowColor = mergedTextOptions.shadow.color || "transparent";
-      ctx.shadowOffsetX = mergedTextOptions.shadow.offsetX;
-      ctx.shadowOffsetY = mergedTextOptions.shadow.offsetY;
-      ctx.shadowBlur = mergedTextOptions.shadow.blur || 0;
-    }
-
-    ctx.fillStyle = mergedTextOptions.color;
-
-    if (mergedTextOptions.maxWidth) {
-      this.drawWrappedText(
-        ctx,
-        mergedTextOptions.text,
-        mergedTextOptions.x,
-        mergedTextOptions.y,
-        mergedTextOptions.maxWidth,
-        mergedTextOptions
-      );
-    } else {
-      ctx.fillText(
-        mergedTextOptions.text,
-        mergedTextOptions.x,
-        mergedTextOptions.y,
-      );
-    }
-
-    if (
-      mergedTextOptions.stroke &&
-      mergedTextOptions.stroke.color &&
-      mergedTextOptions.stroke.width
-    ) {
-      ctx.strokeStyle = mergedTextOptions.stroke.color;
-      ctx.lineWidth = mergedTextOptions.stroke.width;
-
-      ctx.strokeText(
-        mergedTextOptions.text,
-        mergedTextOptions.x,
-        mergedTextOptions.y,
-      );
-    }
-    ctx.restore();
-  }
-
-  drawWrappedText(ctx, text, x, y, maxWidth, mergedTextOptions) {
-    const words = text.split(' ');
-    let currentLine = '';
-
-    for (let n = 0; n < words.length; n++) {
-      const testLine = currentLine + words[n] + ' ';
-      const metrics = ctx.measureText(testLine);
-      const testWidth = metrics.width;
-
-      if (testWidth > maxWidth && n > 0) {
-        const adjustedY = y + (mergedTextOptions.lineHeight || mergedTextOptions.fontSize) / 2;
-        ctx.fillText(currentLine.trim(), x, adjustedY);
-        currentLine = words[n] + ' ';
-        y += mergedTextOptions.lineHeight || mergedTextOptions.fontSize;
-      } else {
-        currentLine = testLine;
-      }
-    }
-
-    const adjustedY = y + (mergedTextOptions.lineHeight || mergedTextOptions.fontSize) / 2;
-    ctx.fillText(currentLine.trim(), x, adjustedY);
-  }
-
-  mergeOptions(defaultOptions, userOptions) {
-    const mergedOptions = { ...defaultOptions };
-
-    for (const key in userOptions) {
-      if (userOptions[key] !== null && userOptions[key] !== undefined) {
-        if (
-          typeof userOptions[key] === "object" &&
-          defaultOptions[key] !== null &&
-          defaultOptions[key] !== undefined
-        ) {
-          mergedOptions[key] = this.mergeOptions(
-            defaultOptions[key],
-            userOptions[key],
-          );
-        } else {
-          mergedOptions[key] = userOptions[key];
-        }
-      }
-    }
-
-    return mergedOptions;
-  }
-
-  createGradient(ctx, gradientOptions, startX, startY, endX, endY) {
-    if (!gradientOptions || !gradientOptions.type) {
-      throw new Error(
-        "Invalid gradient options. Provide a valid object with a type property.",
-      );
-    }
-
-    if (gradientOptions.type === "linear") {
-      if (
-        typeof startX !== "number" ||
-        typeof startY !== "number" ||
-        typeof endX !== "number" ||
-        typeof endY !== "number"
-      ) {
-        throw new Error(
-          "Invalid gradient options for linear gradient. Numeric values are required for startX, startY, endX, and endY.",
-        );
-      }
-    } else if (gradientOptions.type === "radial") {
-      if (
-        typeof gradientOptions.startX !== "number" ||
-        typeof gradientOptions.startY !== "number" ||
-        typeof gradientOptions.startRadius !== "number" ||
-        typeof gradientOptions.endX !== "number" ||
-        typeof gradientOptions.endY !== "number" ||
-        typeof gradientOptions.endRadius !== "number"
-      ) {
-        throw new Error(
-          "Invalid gradient options for radial gradient. Numeric values are required for startX, startY, startRadius, endX, endY, and endRadius.",
-        );
-      }
-    } else {
-      throw new Error('Unsupported gradient type. Use "linear" or "radial".');
-    }
-
-    const gradient =
-      gradientOptions.type === "linear"
-        ? ctx.createLinearGradient(startX, startY, endX, endY)
-        : ctx.createRadialGradient(
-            gradientOptions.startX,
-            gradientOptions.startY,
-            gradientOptions.startRadius,
-            gradientOptions.endX,
-            gradientOptions.endY,
-            gradientOptions.endRadius,
-          );
-
-    for (const colorStop of gradientOptions.colors) {
-      gradient.addColorStop(colorStop.stop, colorStop.color);
-    }
-
-    return gradient;
-  }
-
-  drawRoundedImage(ctx, image, x, y, width, height, borderRadius) {
-    ctx.save();
-    ctx.beginPath();
-
-    if (borderRadius === "circular") {
-      const circleRadius = Math.min(width, height) / 2;
-      ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
-    } else {
-      ctx.moveTo(x + borderRadius, y);
-      ctx.lineTo(x + width - borderRadius, y);
-      ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
-      ctx.lineTo(x + width, y + height - borderRadius);
-      ctx.quadraticCurveTo(
-        x + width,
-        y + height,
-        x + width - borderRadius,
-        y + height,
-      );
-      ctx.lineTo(x + borderRadius, y + height);
-      ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
-      ctx.lineTo(x, y + borderRadius);
-      ctx.quadraticCurveTo(x, y, x + borderRadius, y);
-    }
-
-    ctx.closePath();
-    ctx.clip();
-    ctx.drawImage(image, x, y, width, height);
-    ctx.restore();
-  }
-
-  drawRoundedRect(ctx, x, y, width, height, borderRadius) {
-    if (borderRadius === "circular") {
-      const circleRadius = Math.min(width, height) / 2;
-      ctx.beginPath();
-      ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
-      ctx.closePath();
-    } else if (borderRadius) {
-      ctx.beginPath();
-      ctx.moveTo(x + borderRadius, y);
-      ctx.lineTo(x + width - borderRadius, y);
-      ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
-      ctx.lineTo(x + width, y + height - borderRadius);
-      ctx.quadraticCurveTo(
-        x + width,
-        y + height,
-        x + width - borderRadius,
-        y + height,
-      );
-      ctx.lineTo(x + borderRadius, y + height);
-      ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
-      ctx.lineTo(x, y + borderRadius);
-      ctx.quadraticCurveTo(x, y, x + borderRadius, y);
-      ctx.closePath();
-    } else {
-      ctx.rect(x, y, width, height);
-    }
-  }
-
-  async loadImageFromPathOrURL(imagePath, baseDir) {
-    try {
-      if (!imagePath) {
-        throw new Error("Image path is required.");
-      }
-
-      if (imagePath.startsWith("http")) {
-        if (baseDir) {
-          throw new Error("No need for baseDir when using an image URL.");
-        }
-
-        const response = await axios.get(imagePath, {
-          responseType: "arraybuffer",
-        });
-        return sharp(response.data);
-      } else {
-        if (!baseDir) {
-          throw new Error("baseDir is required for local file paths.");
-        }
-
-        const absolutePath = path.resolve(baseDir, imagePath);
-        return sharp(absolutePath);
-      }
-    } catch (error) {
-      console.error("Error loading image:", error);
-      throw new Error("Failed to load image");
-    }
-  }
-
-  async resize(resizeOptions, baseDir) {
-    try {
-      if (!resizeOptions.imagePath) {
-        throw new Error("Image path is required for resizing.");
-      }
-
-      let imagePath;
-
-      if (Buffer.isBuffer(resizeOptions.imagePath)) {
-        const resizedBuffer = await sharp(resizeOptions.imagePath)
-          .resize(resizeOptions.size.width, resizeOptions.size.height)
-          .toBuffer();
-
-        return resizedBuffer;
-      }
-
-      if (resizeOptions.imagePath.startsWith("http")) {
-        if (baseDir) {
-          throw new Error("No need for baseDir when using an image URL.");
-        }
-
-        imagePath = resizeOptions.imagePath;
-      } else {
-        if (!baseDir) {
-          throw new Error("baseDir is required for local file paths.");
-        }
-
-        imagePath = path.resolve(baseDir, resizeOptions.imagePath);
-      }
-
-      const image = await this.loadImageFromPathOrURL(imagePath);
-
-      const resizedBuffer = await image.resize(resizeOptions.size).toBuffer();
-
-      return resizedBuffer;
-    } catch (error) {
-      console.error("Error resizing image:", error);
-      throw new Error("Failed to resize image");
-    }
-  }
-
-  async imageConverter(imagePath, newExtension, baseDir) {
-    try {
-      let image;
-
-      if (imagePath.startsWith("http")) {
-        const response = await axios.get(imagePath, {
-          responseType: "arraybuffer",
-        });
-        image = sharp(Buffer.from(response.data));
-      } else {
-        if (!imagePath) {
-          throw new Error("Image path is required.");
-        }
-
-        if (!baseDir) {
-          throw new Error("baseDir is required for local file paths.");
-        }
-
-        const absolutePath = path.resolve(baseDir, imagePath);
-        image = sharp(absolutePath);
-      }
-
-      const convertedBuffer = await image.toFormat(newExtension).toBuffer();
-      return convertedBuffer;
-    } catch (error) {
-      console.error("Error changing image extension:", error);
-      throw new Error("Failed to change image extension");
-    }
-  }
-
-  async processImage(imagePath, filters, baseDir = null) {
-    try {
-      let jimpImage;
-
-      if (imagePath.startsWith("http")) {
-        const pngBuffer = await this.imageConverter(imagePath, "png", baseDir);
-        jimpImage = await Jimp.read(pngBuffer);
-      } else {
-        if (!baseDir) {
-          return console.log(`You need to provide __dirname in options.`);
-        }
-        const imagePathResolved = baseDir
-          ? path.resolve(baseDir, imagePath)
-          : imagePath;
-        jimpImage = await Jimp.read(imagePathResolved);
-      }
-
-      for (const filter of filters) {
-        switch (filter.type) {
-          case "flip":
-            jimpImage.flip(filter.horizontal, filter.vertical);
-            break;
-          case "mirror":
-            jimpImage.mirror(filter.horizontal, filter.vertical);
-            break;
-          case "rotate":
-            jimpImage.rotate(filter.deg, filter.mode);
-            break;
-          case "brightness":
-            jimpImage.brightness(filter.value);
-            break;
-          case "contrast":
-            jimpImage.contrast(filter.value);
-            break;
-          case "dither565":
-            jimpImage.dither565();
-            break;
-          case "greyscale":
-            jimpImage.greyscale();
-            break;
-          case "invert":
-            jimpImage.invert();
-            break;
-          case "normalize":
-            jimpImage.normalize();
-            break;
-          case "autocrop":
-            jimpImage.autocrop(filter.tolerance || 0);
-            break;
-          case "crop":
-            jimpImage.crop(filter.x, filter.y, filter.w, filter.h);
-            break;
-          case "fade":
-            jimpImage.fade(filter.factor);
-            break;
-          case "opacity":
-            jimpImage.opacity(filter.factor);
-            break;
-          case "opaque":
-            jimpImage.opaque();
-            break;
-          case "gaussian":
-            jimpImage.gaussian(filter.radius);
-            break;
-          case "blur":
-            jimpImage.blur(filter.radius);
-            break;
-          case "posterize":
-            jimpImage.posterize(filter.levels);
-            break;
-          case "sepia":
-            jimpImage.sepia();
-            break;
-          case "pixelate":
-            jimpImage.pixelate(
-              filter.size,
-              filter.x,
-              filter.y,
-              filter.w,
-              filter.h,
-            );
-            break;
-          default:
-            console.error(`Unsupported filter type: ${filter.type}`);
-        }
-      }
-
-      const outputMimeType = jimpImage._originalMime || Jimp.MIME_PNG;
-
-      return await jimpImage.getBufferAsync(outputMimeType);
-    } catch (error) {
-      console.error("Error processing image:", error.message);
-      console.error(error.stack);
-      throw new Error("Failed to process image");
-    }
-  }
-
-  validateColor(filterColor) {
-    const hexColorRegex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
-    const isHexColor = hexColorRegex.test(filterColor);
-
-    if (!isHexColor) {
-      throw new Error("Invalid color format. Only hex colors are supported.");
-    }
-
-    return true;
-  }
-
-  async colorFilters(imagePath, filterColor, baseDir = null) {
-    try {
-      this.validateColor(filterColor);
-
-      let jimpImage;
-
-      if (imagePath.startsWith("http")) {
-        const pngBuffer = await this.imageConverter(imagePath, "png", baseDir);
-        jimpImage = await Jimp.read(pngBuffer);
-      } else {
-        if (!baseDir) {
-          return console.log(`You need to provide __dirname in options.`);
-        }
-        const imagePathResolved = baseDir
-          ? path.resolve(baseDir, imagePath)
-          : imagePath;
-        jimpImage = await Jimp.read(imagePathResolved);
-      }
-
-      jimpImage.color([{ apply: "mix", params: [filterColor, 100] }]);
-
-      return await jimpImage.getBufferAsync(Jimp.MIME_PNG);
-    } catch (error) {
-      console.error("Error applying color filter:", error.message);
-      console.error(error.stack);
-      throw new Error("Failed to apply color filter");
-    }
-  }
-
-  async bgRemoval(options) {
-    const apiKey = options.apiKey;
-    const formData = new FormData();
-
-    if (!apiKey) {
-      throw new Error(
-        "Error: No Api_Key was provided. We don't provide a default one.",
-      );
-    }
-
-    if (!options.imageUrl) {
-      throw new Error(
-        "Error: Please provide a valid image source (image_url).",
-      );
-    }
-
-    if (
-      options.imageUrl.startsWith("https://media.discordapp.net/attachments/")
-    ) {
-      throw new Error(
-        "Error: Discord image URL isn't suppported at the moment.",
-      );
-    }
-
- const lowerCaseImageUrl = options.imageUrl.toLowerCase();
-if (!lowerCaseImageUrl.endsWith(".png") && !lowerCaseImageUrl.endsWith(".jpg")) {
-  throw new Error("Error: Unsupported image format. Please provide a valid URL ending with .png or .jpg.");
-}
-
-    formData.append("size", options.size || "auto");
-    formData.append("image_url", options.imageUrl);
-    formData.append("type_level", options.type_level || "latest");
-    formData.append("format", options.format || "auto");
-    formData.append("roi", options.roi || "0% 0% 100% 100%");
-    formData.append("crop", options.crop || false);
-    formData.append("crop_margin", options.crop_margin || "0");
-    formData.append("scale", options.scale || "original");
-    formData.append("position", options.position || "original");
-    formData.append("channels", options.channels || "rgba");
-    formData.append("add_shadow", options.add_shadow || false);
-    formData.append("semitransparency", options.semitransparency || true);
-
-    formData.append("bg_color", options.bg_color || null);
-    formData.append("bg_image_url", options.bg_image_url || null);
-
-    try {
-      const response = await axios({
-        method: "post",
-        url: "https://api.remove.bg/v1.0/removebg",
-        data: formData,
-        responseType: "arraybuffer",
-        headers: {
-          ...formData.getHeaders(),
-          "X-Api-Key": apiKey,
-        },
-        encoding: null,
-      });
-
-      if (response.status !== 200) {
-        const errorCode = response.status;
-        switch (errorCode) {
-          case 400:
-            console.error(
-              "Error 400: Invalid parameters or input file unprocessable (no credits charged)",
-            );
-            break;
-          case 402:
-            console.error(
-              "Error 402: Insufficient credits (no credits charged)",
-            );
-            break;
-          case 403:
-            console.error(
-              "Error 403: Authentication failed (no credits charged)",
-            );
-            break;
-          case 429:
-            console.error(
-              "Error 429: Rate limit exceeded (no credits charged)",
-            );
-            break;
-          default:
-            console.error("Error:", errorCode, response.statusText);
-            break;
-        }
-      } else {
-        return response.data;
-      }
-    } catch (error) {
-      console.error("Request failed:", error.message);
-    }
-  }
-
-  async createGIF(images, 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 stream.Writable();
-      bufferStream.buffer = Buffer.alloc(0);
-
-      bufferStream._write = function (chunk, encoding, next) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        next();
-      };
-
-      bufferStream.getBuffer = function () {
-        return this.buffer;
-      };
-
-      return bufferStream;
-    }
-
-    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.canvasSize) {
-        if (
-          options.canvasSize.width !== undefined &&
-          (!Number.isInteger(options.canvasSize.width) ||
-            options.canvasSize.width <= 0)
-        ) {
-          throw new Error(
-            "Canvas width must be a positive integer or undefined.",
-          );
-        }
-
-        if (
-          options.canvasSize.height !== undefined &&
-          (!Number.isInteger(options.canvasSize.height) ||
-            options.canvasSize.height <= 0)
-        ) {
-          throw new Error(
-            "Canvas height must be a positive integer or undefined.",
-          );
-        }
-      }
-
-      if (
-        options.delay !== undefined &&
-        (!Number.isInteger(options.delay) || options.delay <= 0)
-      ) {
-        throw new Error("Delay must be a positive integer or undefined.");
-      }
-
-      if (
-        options.watermark !== undefined &&
-        typeof options.watermark !== "boolean"
-      ) {
-        throw new Error("Watermark must be a boolean or undefined.");
-      }
-
-      if (options.textOverlay !== undefined) {
-        if (
-          !options.textOverlay.text ||
-          typeof options.textOverlay.text !== "string"
-        ) {
-          throw new Error(
-            "Text overlay text is required and must be a string.",
-          );
-        }
-
-        if (
-          options.textOverlay.fontName !== undefined &&
-          typeof options.textOverlay.fontName !== "string"
-        ) {
-          throw new Error(
-            "Text overlay fontName must be a string or undefined.",
-          );
-        }
-
-        if (
-          options.textOverlay.fontPath !== undefined &&
-          typeof options.textOverlay.fontPath !== "string"
-        ) {
-          throw new Error(
-            "Text overlay fontPath must be a string or undefined.",
-          );
-        }
-
-        if (
-          options.textOverlay.fontSize !== undefined &&
-          (!Number.isInteger(options.textOverlay.fontSize) ||
-            options.textOverlay.fontSize <= 0)
-        ) {
-          throw new Error(
-            "Text overlay fontSize must be a positive integer or undefined.",
-          );
-        }
-
-        if (
-          options.textOverlay.fontColor !== undefined &&
-          typeof options.textOverlay.fontColor !== "string"
-        ) {
-          throw new Error(
-            "Text overlay fontColor must be a string or undefined.",
-          );
-        }
-      }
-    }
-    function validateImageObject(imageObject) {
-      return (
-        imageObject &&
-        typeof imageObject === "object" &&
-        "source" in imageObject &&
-        "isRemote" in imageObject
-      );
-    }
-
-    function validateImages(images) {
-      if (!Array.isArray(images)) {
-        throw new Error('The "images" parameter must be an array.');
-      }
-
-      if (images.length === 0) {
-        throw new Error(
-          'The "images" array must contain at least one image object.',
-        );
-      }
-
-      for (const imageObject of images) {
-        if (!validateImageObject(imageObject)) {
-          throw new Error(
-            'Each image object must have "source" and "isRemote" properties.',
-          );
-        }
-      }
-    }
-
-    try {
-      validateOptions(options);
-      validateImages(images);
-
-      const canvasWidth = options.canvasSize?.width || 1200;
-      const canvasHeight = options.canvasSize?.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);
-      encoder.setDelay(options.delay || 3000);
-
-      const canvas = createCanvas(canvasWidth, canvasHeight);
-      const ctx = canvas.getContext("2d");
-
-      for (const imageInfo of images) {
-        const image = imageInfo.isRemote
-          ? await loadImage(imageInfo.source)
-          : await loadImage(imageInfo.source);
-
-        const resizedImage = await resizeImage(
-          image,
-          canvasWidth,
-          canvasHeight,
-        );
-
-        ctx.clearRect(0, 0, canvas.width, canvas.height);
-        ctx.drawImage(resizedImage, 0, 0);
-
-        if (options.watermark) {
-          const watermark = await loadImage("");
-          ctx.drawImage(watermark, 10, canvasHeight - watermark.height - 10);
-        }
-
-        if (options.textOverlay) {
-          const textOptions = options.textOverlay;
-          const fontPath = textOptions.fontPath;
-          const fontName = textOptions.fontName || "Arial";
-          const fontSize = textOptions.fontSize || 20;
-          const fontColor = textOptions.fontColor || "white";
-          const x = textOptions.x || 10;
-          const y = textOptions.y || 30;
-
-          if (fontPath) {
-            GlobalFonts.registerFromPath(
-              path.join(options.basDir, fontPath),
-              fontName,
-            );
-          }
-
-          ctx.font = `${fontSize}px ${fontName}`;
-          ctx.fillStyle = fontColor;
-          ctx.fillText(textOptions.text, x, y);
-        }
-
-        encoder.addFrame(ctx);
-      }
-
-      encoder.finish();
-      outputStream.end();
-
-      if (options.outputFormat === "file") {
-        if (!options.outputFile) {
-          throw new Error("Please provide a valid file path");
-        }
-        await new Promise((resolve) => outputStream.on("finish", resolve));
-        console.log(`GIF created successfully at ${options.outputFile}`);
-      } else if (options.outputFormat === "base64") {
-        outputStream.on("finish", () => {
-          console.log("GIF created successfully");
-        });
-
-        return outputStream.buffer.toString("base64");
-      } else if (options.outputFormat === "attachment") {
-        outputStream.on("finish", () => {
-          console.log("GIF created successfully");
-        });
-
-        const gifStream = encoder.createReadStream();
-        return [{ attachment: gifStream, name: "gif.js" }];
-      } else if (options.outputFormat === "buffer") {
-        outputStream.on("finish", () => {
-          console.log("GIF created successfully");
-        });
-
-        return outputStream.buffer;
-      } else {
-        throw new Error(
-          "Error: Please provide a valid format: 'buffer', 'base64', 'attachment',or 'output/file/path'.",
-        );
-      }
-    } catch (e) {
-      console.error(e);
-    }
-  }
-}
-
-module.exports = { ApexPainter };