apexify.js 3.3.6 → 3.3.8

package/lib/canvas/ApexPainter.ts

@@ -1,5 +1,4 @@
 import { createCanvas, loadImage, GlobalFonts } from "@napi-rs/canvas";
-import axios, { responseEncoding } from "axios";
 import path from 'path';
 import GIFEncoder from 'gifencoder';
 import { PassThrough, Writable} from 'stream'
@@ -11,55 +10,57 @@ import { CanvasConfig, TextObject, ImageProperties, ImageObject, GIFOptions, GIF
 import {  } from "./utils/general functions";
 
 export class ApexPainter {
-    async createCanvas(canvas: CanvasConfig): Promise<Buffer> {
-        let canvasWidth: number = canvas.width || 500;
-        let canvasHeight: number = canvas.height || 500;
-        let borderRadius: number | string = canvas.borderRadius || 0;
 
-        if (canvas.customBg) {
-            try {
-                const response = await axios.get(canvas.customBg, { responseType: 'arraybuffer' });
-                const imageBuffer = Buffer.from(response.data, 'binary');
-                const image = await loadImage(imageBuffer);
-
-                canvasWidth = image.width;
-                canvasHeight = image.height;
-            } catch (error) {
-                console.error('Error loading custom background image:', error);
+  async createCanvas(canvas: CanvasConfig): Promise<Buffer> {
+    let canvasWidth: number = canvas.width || 500;
+    let canvasHeight: number = canvas.height || 500;
+    let borderRadius: number | string = canvas.borderRadius || 0;
+
+    if (canvas.customBg) {
+        try {
+            const response = await fetch(canvas.customBg);
+            if (!response.ok) {
+                throw new Error("Failed to fetch background image.");
             }
+            const buffer = await response.arrayBuffer();
+            const image = await loadImage(Buffer.from(buffer));
+            canvasWidth = image.width;
+            canvasHeight = image.height;
+        } catch (error) {
+            console.error('Error loading custom background image:', error);
         }
+    }
 
-  
-   
-        const canvasInstance = createCanvas(canvasWidth, canvasHeight);
-        const ctx: any = canvasInstance.getContext('2d');
+    const canvasInstance = createCanvas(canvasWidth, canvasHeight);
+    const ctx: any = 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);
+    if (!ctx) {
+        throw new Error('Unable to get 2D rendering context from canvas');
+    }
 
-        applyShadow(ctx, canvas.shadow, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+    applyRotation(ctx, canvas.rotation || 0, 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);
-        }
+    applyShadow(ctx, canvas.shadow, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
 
-        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);
+    if (typeof borderRadius === 'string') {
+        circularBorder(ctx, canvasWidth, canvasHeight);
+    } else if (typeof borderRadius === 'number') {
+        radiusBorder(ctx, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight, borderRadius);
+    }
 
-        return canvasInstance.toBuffer('image/png');
+    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 canvasInstance.toBuffer('image/png');
+  }
+
     async createImage(images: ImageProperties[], canvasBuffer: Buffer): Promise<Buffer> {
 
         if (!canvasBuffer) {
@@ -517,51 +518,45 @@ export class ApexPainter {
     }
 
     try {
-
-    let img: any;
-    const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
-
-    const isShape = shapeNames.includes(source.toLowerCase());
-
-    if (source.startsWith('http')) {
-        const response = await axios.get(source, { responseType: 'arraybuffer' });
-        const imageBuffer = Buffer.from(response.data, 'binary');
-        img = await loadImage(imageBuffer);
-    } else if (isShape) {
-        drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient });
-    } else {
-        const imagePath = path.join(process.cwd(), source);
-        try {
-            img = await loadImage(imagePath);
-        } catch (e: any) {
-            throw new Error(`Error loading image: ${e.message}`);
+        let img: any;
+        const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
+        const isShape = shapeNames.includes(source.toLowerCase());
+
+        if (source.startsWith('http')) {
+            const response = await fetch(source);
+            if (!response.ok) {
+                throw new Error("Failed to fetch image.");
+            }
+            const buffer = await response.arrayBuffer();
+            img = await loadImage(Buffer.from(buffer));
+        } else if (isShape) {
+            drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient });
+        } else {
+            const imagePath = path.join(process.cwd(), source);
+            try {
+                img = await loadImage(imagePath);
+            } catch (e: any) {
+                throw new Error(`Error loading image: ${e.message}`);
+            }
         }
-    }
-
-    if (img !== undefined) {
-
-      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);
- 
-      applyStroke(ctx, stroke, x, y, width, height);
-
-      ctx.restore();
-    } else {
-         if (!isShape) {
-           throw new Error('Invalid image source or shape name');
+        if (img !== undefined) {
+            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);
+            applyStroke(ctx, stroke, x, y, width, height);
+            ctx.restore();
+        } else {
+            if (!isShape) {
+                throw new Error('Invalid image source or shape name');
+            }
         }
-      }
-
-    } catch (e: any) {
-      throw new Error(e.message)
-    } 
+    } catch (error: any) {
+        throw new Error(error.message);
+    }
+  
   }
-
   public validHex(hexColor: string): any {
     const hexPattern = /^#[0-9a-fA-F]{6}$/;
     if (!hexPattern.test(hexColor)) {

package/lib/canvas/utils/bg.ts

@@ -1,6 +1,5 @@
 import { loadImage } from "@napi-rs/canvas";
 import { CanvasConfig } from './types';
-import axios from 'axios';
 import fs from 'fs';
 import path from 'path';
 
@@ -58,8 +57,12 @@ export async function customBackground(ctx: any, canvas: CanvasConfig): Promise<
             let imagePath: string;
 
             if (canvas.customBg.startsWith('http')) {
-                const response = await axios.get(canvas.customBg, { responseType: 'arraybuffer' });
-                imageBuffer = Buffer.from(response.data, 'binary');
+                const response = await fetch(canvas.customBg);
+                if (!response.ok) {
+                    throw new Error("Failed to fetch custom background image.");
+                }
+                const buffer = await response.arrayBuffer();
+                imageBuffer = Buffer.from(buffer);
             } else {
                 imagePath = path.join(process.cwd(), canvas.customBg);
                 imageBuffer = fs.readFileSync(imagePath);
@@ -72,7 +75,7 @@ export async function customBackground(ctx: any, canvas: CanvasConfig): Promise<
 
             ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
 
-        } catch (error) {
+        } catch (error: any) {
             console.error('Error loading custom background image:', error);
         }
     }

package/lib/canvas/utils/charts.ts

@@ -1,14 +1,13 @@
 import { createCanvas, loadImage } from '@napi-rs/canvas';
 import { barChart_1, bgConfig, DataItem, KeyBoxConfig, PieDataConfig, PieChartData, LineChartConfig, DataPoint } from "./types";
 import path from 'path';
-import axios from 'axios';
 
 
 ////////////////////////////////////////BAR CHARTS////////////////////////////////////////
 
 export async function verticalBarChart(data: barChart_1) {
     try {
-        const { chartData, xLabels, yLabels, data: { xAxis, yAxis, keys, keyColor, xTitle, yTitle, labelStyle } } = data;
+        const { chartData, xLabels, yLabels, data: { xAxis, yAxis, keys, xTitle, yTitle, labelStyle } } = data;
 
         if (!xLabels || !yLabels || !xAxis || !yAxis) {
             throw new Error('Required data is missing.');
@@ -33,15 +32,24 @@ export async function verticalBarChart(data: barChart_1) {
         const chartHeight = canvasHeight * (chartData?.heightPerc || 0.8); 
 
         if (chartData?.bg?.image) {
-            if (chartData.bg?.image.startsWith('http')) {
-                const response = await axios.get(chartData.bg?.image, { responseType: 'arraybuffer' });
-                img = await loadImage(Buffer.from(response.data, 'binary'));
-            } else {
-                const imagePath =path.join(process.cwd(), chartData.bg?.image);
-                img = await loadImage(imagePath);
-
+            try {
+                let img;
+                if (chartData.bg.image.startsWith('http')) {
+                    const response = await fetch(chartData.bg.image);
+                    if (!response.ok) {
+                        throw new Error("Failed to fetch image.");
+                    }
+                    const buffer = await response.arrayBuffer();
+                    img = await loadImage(Buffer.from(buffer));
+                } else {
+                    const imagePath = path.join(process.cwd(), chartData.bg.image);
+                    img = await loadImage(imagePath);
+                }
+            } catch (error) {
+                console.error('Error loading image:', error);
             }
         }
+        
         const canvas = createCanvas(800, 600);
         const ctx = canvas.getContext('2d');
 
@@ -347,26 +355,32 @@ export async function lineChart(data: { data: DataPoint[][], lineConfig: LineCha
 
     let img: any;
     if (data.lineConfig?.canvas?.image) {
-        if (data.lineConfig?.canvas?.image.startsWith('http')) {
-            const response = await axios.get(data.lineConfig?.canvas?.image, { responseType: 'arraybuffer' });
-            img = await loadImage(Buffer.from(response.data, 'binary'));
-        } else {
-            const imagePath = path.join(process.cwd(), data.lineConfig?.canvas?.image);
-            img = await loadImage(imagePath);
-
+        try {
+            if (data.lineConfig.canvas.image.startsWith('http')) {
+              const response = await fetch(data.lineConfig.canvas.image);
+                if (!response.ok) {
+                  throw new Error("Failed to fetch image.");
+                }
+              const buffer = await response.arrayBuffer();
+              img = await loadImage(Buffer.from(buffer));
+            } else {
+              const imagePath = path.join(process.cwd(), data.lineConfig.canvas.image);
+              img = await loadImage(imagePath);
+            }
+        } catch (error) {
+          console.error('Error loading image:', error);
         }
     }
 
-
     const canvas = createCanvas(canvasWidth, canvasHeight);
     const ctx = canvas.getContext('2d');
 
     const xAxisLabels = data.data[0].map(point => point.label);
-    const yAxisLabel = 'Y Axis';
-    ctx.font = '16px Arial';
+    const yAxisLabel = data.lineConfig?.yaxisLabel?.label || 'Y Axis';
+    ctx.font = `${data.lineConfig?.yaxisLabel?.fontSize || 16} Arial`;
 
     if (data.lineConfig?.canvas?.image) { 
-        ctx.drawImage(img, 0, 0, 800, 600);
+        ctx.drawImage(img, 0, 0, canvasWidth, canvasHeight);
     } else {
         ctx.fillStyle = data.lineConfig?.canvas?.bgColor || '#f0f0f0';
         ctx.fillRect(0, 0, canvasWidth, canvasHeight);
@@ -401,7 +415,8 @@ export async function lineChart(data: { data: DataPoint[][], lineConfig: LineCha
     ctx.save();
     ctx.translate(20, canvasHeight / 2);
     ctx.rotate(-Math.PI / 2);
-    ctx.fillText(yAxisLabel, 0, 0);
+    ctx.fillStyle = data.lineConfig?.yaxisLabel?.color || 'black'; 
+    ctx.fillText(yAxisLabel, data.lineConfig?.yaxisLabel?.y || 0, data.lineConfig?.yaxisLabel?.x || 0);
     ctx.restore();
 
     let maxY = 0;
@@ -423,7 +438,7 @@ export async function lineChart(data: { data: DataPoint[][], lineConfig: LineCha
         ctx.strokeStyle = lineConfig?.lineColor[index] || 'blue';
         ctx.lineWidth = 2;
 
-        const tension = lineConfig.lineTension[index] || 0.1;
+        const tension = (lineConfig && lineConfig.lineTension && lineConfig.lineTension[index]) || 0.1;
 
         line.forEach((point, index) => {
             const x = index * segmentWidth + 50;

package/lib/canvas/utils/general functions.ts

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import path from 'path'
 import sharp from 'sharp';
 import { cropOptions } from './types';
@@ -6,24 +5,26 @@ import { createCanvas, loadImage } from '@napi-rs/canvas';
 import Jimp from 'jimp';
 
 export async function loadImages(imagePath: string) {
-    try {
-        if (!imagePath) {
-            throw new Error("Image path is required.");
-        }
+  try {
+      if (!imagePath) {
+          throw new Error("Image path is required.");
+      }
 
-        if (imagePath.startsWith("http")) {
-            const response = await axios.get<ArrayBuffer>(imagePath, {
-                responseType: "arraybuffer",
-            });
-            return sharp(response.data);
-        } else {
-            const absolutePath = path.join(process.cwd(), imagePath);
-            return sharp(absolutePath);
-        }
-    } catch (error) {
-        console.error("Error loading image:", error);
-        throw new Error("Failed to load image");
-    }
+      if (imagePath.startsWith("http")) {
+          const response = await fetch(imagePath);
+          if (!response.ok) {
+              throw new Error("Failed to fetch image.");
+          }
+          const buffer = await response.arrayBuffer();
+          return sharp(buffer);
+      } else {
+          const absolutePath = path.join(process.cwd(), imagePath);
+          return sharp(absolutePath);
+      }
+  } catch (error) {
+      console.error("Error loading image:", error);
+      throw new Error("Failed to load image");
+  }
 }
 
 export async function resizingImg(resizeOptions: any): Promise<any> { 
@@ -52,13 +53,13 @@ export async function resizingImg(resizeOptions: any): Promise<any> {
 
     ctx.drawImage(image, 0, 0, resizeOptions.size?.width || 500, resizeOptions.size?.height || 500);
 
-    const resizedBuffer = await canvas.toBuffer('image/png');
+    const resizedBuffer = canvas.toBuffer('image/png');
 
     return resizedBuffer;
 } catch (error) {
     console.error("Error resizing image:", error);
     throw new Error("Failed to resize image");
-}
+  }
 }
 
 export async function converter(imagePath: string, newExtension: string) {
@@ -73,10 +74,12 @@ export async function converter(imagePath: string, newExtension: string) {
       let image: sharp.Sharp;
 
       if (imagePath.startsWith("http")) {
-          const response = await axios.get<ArrayBuffer>(imagePath, {
-              responseType: "arraybuffer",
-          });
-          image = sharp(Buffer.from(response.data));
+          const response = await fetch(imagePath);
+          if (!response.ok) {
+              throw new Error("Failed to fetch image.");
+          }
+          const buffer = await response.arrayBuffer();
+          image = sharp(Buffer.from(buffer));
       } else {
           if (!imagePath) {
               throw new Error("Image path is required.");
@@ -329,12 +332,16 @@ export async function detectColors(imagePath: string): Promise<{ color: string;
   try {
       let image: any;
       if (imagePath.startsWith('http')) {
-          const response = await axios.get(imagePath, { responseType: 'arraybuffer' });
-          const buffer = Buffer.from(response.data, 'binary');
-          image = await loadImage(buffer);
+          const response = await fetch(imagePath);
+          if (!response.ok) {
+              throw new Error("Failed to fetch image.");
+          }
+          const buffer = await response.arrayBuffer();
+          image = await loadImage(Buffer.from(buffer));
       } else {
-        const localImagePath = path.join(process.cwd(), imagePath);
-        image = await loadImage(localImagePath);      }
+          const localImagePath = path.join(process.cwd(), imagePath);
+          image = await loadImage(localImagePath);
+      }
 
       const canvas = createCanvas(image.width, image.height);
       const ctx = canvas.getContext('2d') as any;
@@ -376,12 +383,16 @@ export async function removeColor(inputImagePath: string, colorToRemove: { red:
   try {
       let image: any;
       if (inputImagePath.startsWith('http')) {
-          const response = await axios.get(inputImagePath, { responseType: 'arraybuffer' });
-          const buffer = Buffer.from(response.data, 'binary');
-          image = await loadImage(buffer);
+          const response = await fetch(inputImagePath);
+          if (!response.ok) {
+              throw new Error("Failed to fetch image.");
+          }
+          const buffer = await response.arrayBuffer();
+          image = await loadImage(Buffer.from(buffer));
       } else {
-        const localImagePath = path.join(process.cwd(), inputImagePath);
-        image = await loadImage(localImagePath);      }
+          const localImagePath = path.join(process.cwd(), inputImagePath);
+          image = await loadImage(localImagePath);
+      }
 
       const canvas = createCanvas(image.width, image.height);
       const ctx = canvas.getContext('2d') as any;
@@ -411,24 +422,31 @@ export async function removeColor(inputImagePath: string, colorToRemove: { red:
 }
 
 export async function bgRemoval(imgURL: string, API_KEY: string): Promise<Buffer | undefined> {
-    try {
-     
+  try {
       if (!API_KEY) {
-        throw new Error("API_KEY is required. Please visit remove.bg, create an account, and obtain your API key at: https://accounts.kaleido.ai/users/sign_in#api-key");
+          throw new Error("API_KEY is required. Please visit remove.bg, create an account, and obtain your API key at: https://accounts.kaleido.ai/users/sign_in#api-key");
       }
-            const response = await axios.post('https://api.remove.bg/v1.0/removebg', {
-            image_url: imgURL,
-            size: 'auto'
-        }, {
-            headers: {
-                'X-Api-Key': API_KEY
-            },
-            responseType: 'arraybuffer'
-        });
-
-        return Buffer.from(response.data, 'binary');
-    } catch (error) {
-        console.error('Error:', error);
-        return undefined;
-    }
-}
+
+      const response = await fetch('https://api.remove.bg/v1.0/removebg', {
+          method: 'POST',
+          headers: {
+              'X-Api-Key': API_KEY,
+              'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+              image_url: imgURL,
+              size: 'auto'
+          }),
+      });
+
+      if (!response.ok) {
+          throw new Error("Failed to remove background.");
+      }
+
+      const buffer = await response.arrayBuffer();
+      return Buffer.from(buffer);
+  } catch (error) {
+      console.error('Error:', error);
+      return undefined;
+  }
+}

package/lib/canvas/utils/types.ts

@@ -113,8 +113,8 @@ export interface TextObject {
     color?: string;
     maxWidth?: number;
     lineHeight?: number;
-    textAlign?: CanvasTextAlign;
-    textBaseline?: CanvasTextBaseline;
+    textAlign?: string | "end" | "center" | "left" | "right" | "start";
+    textBaseline?: string | "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
     shadow?: {
         color?: string;
         offsetX?: number;
@@ -372,19 +372,26 @@ export interface LineChartConfig {
     yLabels: string[];
     fillArea: { color: string }[];
     lineColor: string[];
-    plot: {
+    plot?: {
         enable: boolean;
         color: string[];
         size: number;
     };
-    lineTension: number[];
-    grid: {
+    yaxisLabel?: {
+        label?: string;
+        x?: number;
+        y?: number; 
+        color?: string;
+        fontSize?: string;
+    };
+    lineTension?: number[];
+    grid?: {
         type: 'vertical' | 'horizontal' | 'both' | string;
         color: string;
         width: number;
     };
-    keys: { [color: string]: string };
-    keysConfig: {
+    keys?: { [color: string]: string };
+    keysConfig?: {
         radius?: number;
         keyPadding?: number;
         textPadding?: number;

package/lib/index.ts

@@ -1,4 +1,3 @@
-import axios from "axios";
 import * as path from "path";
 import * as fs from "fs";
 
@@ -15,10 +14,12 @@ const getLibraryVersion = function(library: string): string {
     return version;
 };
 
-axios
-    .get("https://registry.npmjs.com/-/v1/search?text=apexify.js")
-    .then(function(response: any) {
-        const version: string = response.data.objects[0]?.package?.version;
+fetch("https://registry.npmjs.com/-/v1/search?text=apexify.js")
+    .then(function(response: Response) {
+        return response.json();
+    })
+    .then(function(data: any) {
+        const version: string = data.objects[0]?.package?.version;
         if (version && getLibraryVersion("apexify.js") !== version) {
             console.error(CYAN +
                 "Error: Please update apexify.js to the latest version (" + version + ")." +
@@ -27,7 +28,6 @@ axios
     })
     .catch(function(error: any) {});
 
-
 import { ApexAI, ApexChat, ApexImagine, ApexPainter } from "./utils";
 
 export { ApexPainter, ApexAI, ApexImagine, ApexChat };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "apexify.js",
-    "version": "3.3.6",
+    "version": "3.3.8",
     "description": "Ai and Canvas library. Supports typescript and javascript",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -140,8 +140,8 @@
     "dependencies": {
         "@iamtraction/google-translate": "^2.0.1",
         "@napi-rs/canvas": "^0.1.51",
+        "apexify.js": "^3.3.6",
         "api": "^6.1.1",
-        "axios": "^1.6.7",
         "gifencoder": "^2.0.1",
         "hercai": "^12.2.0",
         "jimp": "^0.22.12",
@@ -153,7 +153,7 @@
         "@types/gifencoder": "^2.0.3",
         "@types/node": "^20.11.25",
         "@types/pdf-parse": "^1.1.4",
-        "discord.js": "^14.14.1",
+        "discord.js": "^14.15.2",
         "typescript": "^5.4.2"
     }
 }