apexify.js 4.7.95 → 4.8.0

package/lib/ai/modals/groq/whisper.ts

@@ -0,0 +1,114 @@
+import Groq from "groq-sdk";
+import fs from "fs";
+import path from "path";
+import { URL } from "url";
+import https from "https";
+
+/**
+ * Gets the file size of a given path.
+ */
+function getFileSize(filePath: string): number {
+    return fs.statSync(filePath).size;
+}
+
+/**
+ * Creates a readable stream from a local file or a remote URL.
+ */
+async function createReadableStream(filepathOrUrl: string): Promise<{ stream: fs.ReadStream | null; tempFilePath?: string; error?: string }> { 
+    const maxFileSizeBytes = 25 * 1024 * 1024; // 25MB limit
+
+    if (filepathOrUrl.startsWith("http")) {
+        const parsedUrl = new URL(filepathOrUrl);
+        const fileExtension = path.extname(parsedUrl.pathname);
+        const tempFilePath = `temp-file-${Date.now()}${fileExtension}`;
+
+        return new Promise((resolve, reject) => {
+            const file = fs.createWriteStream(tempFilePath);
+            const request = https.get(filepathOrUrl, (response) => {
+                let fileSize = 0;
+
+                response.on("data", (chunk) => {
+                    fileSize += chunk.length;
+                    if (fileSize > maxFileSizeBytes) {
+                        request.destroy();
+                        file.close();
+                        fs.unlink(tempFilePath, () => resolve({ stream: null, error: "File size exceeds the limit (25MB)" }));
+                        return;
+                    }
+                });
+
+                response.pipe(file);
+                file.on("finish", () => {
+                    file.close();
+                    resolve({ stream: fs.createReadStream(tempFilePath), tempFilePath }); // ✅ Ensure fs.ReadStream
+                });
+            });
+
+            request.on("error", (err) => {
+                fs.unlink(tempFilePath, () => reject(err));
+            });
+        });
+    } else {
+        if (getFileSize(filepathOrUrl) > maxFileSizeBytes) {
+            return { stream: null, error: "File size exceeds the limit (25MB)" };
+        }
+        return { stream: fs.createReadStream(filepathOrUrl) }; // ✅ Ensure fs.ReadStream
+    }
+}
+
+/**
+ * Transcribes audio using Groq Whisper API.
+ */
+export async function whisper(prompt: string, filepath: string, lang?: string, API_KEY?: string) {
+    try {
+
+
+        const groq = new Groq({
+          apiKey: API_KEY || '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',
+        });
+  
+  
+        // Ensure filepath is properly resolved
+        const resolvedFilePath = filepath.startsWith("http") || path.isAbsolute(filepath)
+            ? filepath
+            : path.join(process.cwd(), filepath);
+
+        const { stream: fileStream, tempFilePath, error } = await createReadableStream(resolvedFilePath);
+
+        if (error) return error;
+        if (!fileStream) return "Failed to create a readable file stream.";
+
+        // ✅ Ensure `fileStream` is a valid `fs.ReadStream`
+        const transcription = await groq.audio.transcriptions.create({
+            file: fileStream as fs.ReadStream, // ✅ Ensure correct type
+            model: "whisper-large-v3-turbo",
+            prompt: prompt,
+            temperature: 1,
+            language: lang || "eng",
+            response_format: "verbose_json",
+        });
+
+        // ✅ Delete the temp file if it was downloaded from a URL
+        if (tempFilePath && fs.existsSync(tempFilePath)) {
+            fs.unlinkSync(tempFilePath);
+        }
+
+        return transcription.text;
+    } catch (err: any) {
+        if (err?.status) {
+            switch (err.status) {
+                case 400:
+                    return "Bad request, try again after a minute.";
+                case 429:
+                    return "Rate limit exceeded, try again later or provide your own API key.";
+                case 401:
+                    return "Invalid API key provided.";
+                default:
+                    console.error(err);
+                    return "An unknown error occurred.";
+            }
+        }
+        console.error(err);
+        return "An unknown error occurred.";
+    }
+}

package/lib/ai/utils.ts

@@ -1,7 +1,7 @@
 import { readFile } from "./functions/readFiles";
 import { ApexChat, ApexImagine, ApexListener, ApexVideo, ApexText2Speech, resetHistory } from "./ApexModules";
 import { typeWriter } from "./functions/typeWriter" ;
-import { groqAnalyzer } from "./modals-chat/groq/imageAnalyzer";
+import { groqAnalyzer } from "./modals/groq/imageAnalyzer";
 
 
 export {

package/lib/canvas/ApexPainter.ts

@@ -3,13 +3,13 @@ import GIFEncoder from "gifencoder";
 import ffmpeg from 'fluent-ffmpeg';
 import { PassThrough} from "stream";
 import axios from 'axios';
-import fs from "fs";
+import fs, { PathLike } from "fs";
 import path from "path";
 import { OutputFormat, CanvasConfig, TextObject, ImageProperties, GIFOptions, GIFResults, CustomOptions, cropOptions,
      drawBackgroundGradient, drawBackgroundColor, customBackground, customLines, applyRotation, applyStroke,
      applyShadow, imageRadius, drawShape, drawText, converter, resizingImg, applyColorFilters, imgEffects,verticalBarChart, pieChart,
      lineChart, cropInner, cropOuter, bgRemoval, detectColors, removeColor, dataURL, base64, arrayBuffer, blob, url, GradientConfig, Frame,
-     PatternOptions, ExtractFramesOptions, backgroundRadius, applyZoom, ResizeOptions, applyPerspective
+     PatternOptions, ExtractFramesOptions, backgroundRadius, applyZoom, ResizeOptions, applyPerspective, MaskOptions, BlendOptions
     } from "./utils/utils";
 
   interface CanvasResults {
@@ -114,6 +114,7 @@ export class ApexPainter {
     
     const canvas = createCanvas(baseImage.width, baseImage.height);
     const ctx = canvas.getContext('2d') as SKRSContext2D | null;
+
     if (!ctx) {
       throw new Error('Unable to get 2D rendering context from canvas');
     }
@@ -164,7 +165,6 @@ export class ApexPainter {
                 );
             }
 
-            const size = { width: existingImage.width, height: existingImage.height };
             drawText(ctx, mergedTextOptions);
         }
 
@@ -336,24 +336,24 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
     return resizingImg(resizeOptions)
   }
 
-  async imgConverter(imagePath: string, newExtension: string) {
-    return converter(imagePath, newExtension)
+  async imgConverter(source: string, newExtension: string) {
+    return converter(source, newExtension)
   }
 
-  async processImage(imagePath: string, filters: any[]) {
-    return imgEffects(imagePath, filters)
+  async effects(source: string, filters: any[]) {
+    return imgEffects(source, filters)
   }
 
-  async colorsFilter(imagePath: string, filterColor: any, opacity?: number) {
-    return applyColorFilters(imagePath, filterColor, opacity)
+  async colorsFilter(source: string, filterColor: any, opacity?: number) {
+    return applyColorFilters(source, filterColor, opacity)
   }
 
-  async colorAnalysis(imagePath: string) {
-    return detectColors(imagePath)
+  async colorAnalysis(source: string) {
+    return detectColors(source)
   }
 
-  async colorsRemover(imagePath: string, colorToRemove: { red: number, green: number, blue: number }) {
-    return removeColor(imagePath, colorToRemove)
+  async colorsRemover(source: string, colorToRemove: { red: number, green: number, blue: number }) {
+    return removeColor(source, colorToRemove)
   }
 
   async removeBackground(imageURL: string, apiKey: string) {
@@ -362,43 +362,52 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
 
   async blend(
     layers: {
-      image: string | Buffer; 
-      blendMode: 'source-over' | 'source-in' | 'source-out' | 'source-atop' | 
-                 'destination-over' | 'destination-in' | 'destination-out' | 
-                 'destination-atop' | 'lighter' | 'copy' | 'xor' | 
-                 'multiply' | 'screen' | 'overlay' | 'darken' | 
-                 'lighten' | 'color-dodge' | 'color-burn' | 
-                 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 
+      image: string | Buffer;
+      blendMode: 'source-over' | 'source-in' | 'source-out' | 'source-atop' |
+                 'destination-over' | 'destination-in' | 'destination-out' |
+                 'destination-atop' | 'lighter' | 'copy' | 'xor' |
+                 'multiply' | 'screen' | 'overlay' | 'darken' |
+                 'lighten' | 'color-dodge' | 'color-burn' |
+                 'hard-light' | 'soft-light' | 'difference' | 'exclusion' |
                  'hue' | 'saturation' | 'color' | 'luminosity';
-      position?: { x: number; y: number }; 
-      opacity?: number; 
+      position?: { x: number; y: number };
+      opacity?: number;
     }[],
-    baseImageBuffer: Buffer
+    baseImageBuffer: Buffer,
+    defaultBlendMode: 'source-over' | 'source-in' | 'source-out' | 'source-atop' |
+                      'destination-over' | 'destination-in' | 'destination-out' |
+                      'destination-atop' | 'lighter' | 'copy' | 'xor' |
+                      'multiply' | 'screen' | 'overlay' | 'darken' |
+                      'lighten' | 'color-dodge' | 'color-burn' |
+                      'hard-light' | 'soft-light' | 'difference' | 'exclusion' |
+                      'hue' | 'saturation' | 'color' | 'luminosity' = 'source-over'
   ): Promise<Buffer> {
     try {
       const baseImage = await loadImage(baseImageBuffer);
       const canvas = 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 loadImage(layer.image);
-        ctx.globalAlpha = layer.opacity !== undefined ? layer.opacity : 1.0; 
+        ctx.globalAlpha = layer.opacity !== undefined ? layer.opacity : 1.0;
   
         ctx.globalCompositeOperation = layer.blendMode;
         ctx.drawImage(layerImage, layer.position?.x || 0, layer.position?.y || 0);
       }
   
       ctx.globalAlpha = 1.0;
-      ctx.globalCompositeOperation = 'source-over'; 
+      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: any, type: { chartType: string, chartNumber: number}) {
 
@@ -489,13 +498,9 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
     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 (opacity !== undefined) {
-      ctx.globalAlpha = opacity;
-    }
-  
+
     if (isShape) {
-      drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition, filling });
-      ctx.globalAlpha = 1.0;
+      drawShape(ctx, { source, x, y, width, height, opacity, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition, filling });
       return;
     }
   
@@ -526,6 +531,10 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
       ctx.scale(scale, scale);
     }
   
+    if (opacity !== undefined) {
+      ctx.globalAlpha = opacity;
+    }
+  
     if (blur > 0) {
       ctx.filter = `blur(${blur}px)`;
     }
@@ -538,10 +547,14 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
     }
   
     imageRadius(ctx, loadedImage, x, y, width, height, borderRadius, borderPosition);
+    ctx.globalAlpha = 1.0;
+
+    if (stroke?.opacity) ctx.globalAlpha = stroke.opacity as number;
+
     applyStroke(ctx, stroke, x, y, width, height, undefined);
-  
-    ctx.restore();
     ctx.globalAlpha = 1.0;
+
+    ctx.restore();
   }
   
 
@@ -623,7 +636,7 @@ async extractFrames(videoSource: string | Buffer, options: ExtractFramesOptions)
  * @param {Object} options - Options to customize the pattern.
  * @returns {Promise<Buffer>} - The adjusted image buffer.
  */
-async setPatternBackground(buffer:Buffer, options: PatternOptions) {
+async patterns(buffer:Buffer, options: PatternOptions) {
 
     const img = await loadImage(buffer);
     const canvas = createCanvas(img.width, img.height);
@@ -663,6 +676,15 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
         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.');
     }
@@ -682,7 +704,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async fillWithGradient(
+  private async fillWithGradient(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -727,7 +749,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async  drawDotsPattern(
+  private async drawDotsPattern(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -759,7 +781,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async drawStripesPattern(
+  private async drawStripesPattern(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -795,7 +817,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async drawGridPattern(
+    private async drawGridPattern(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -833,7 +855,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async drawCheckerboardPattern(
+  private async drawCheckerboardPattern(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -844,7 +866,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
     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;
@@ -862,7 +884,7 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
    * @param x The x offset of the area.
    * @param y The y offset of the area.
    */
-  async drawCustomPattern(
+  private async drawCustomPattern(
     ctx: SKRSContext2D,
     width: number,
     height: number,
@@ -881,7 +903,152 @@ async setPatternBackground(buffer:Buffer, options: PatternOptions) {
     ctx.fillRect(0, 0, width, height);
     ctx.resetTransform();
   }
+
+  private async drawWavePattern(ctx: SKRSContext2D, width: number, height: number, options: PatternOptions, 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();
+    }
+  }
+
+
+  private async drawNoisePattern(ctx: SKRSContext2D, width: number, height: number, 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);
+  }
+
+
+  private async drawDiagonalCheckerboardPattern(ctx: SKRSContext2D, width: number, height: number, options: PatternOptions, 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: string | Buffer | PathLike | Uint8Array, 
+  maskSource: string | Buffer | PathLike | Uint8Array, 
+  options: MaskOptions = { type: "alpha" }
+): Promise<Buffer> {
+  const img = await loadImage(source);
+  const mask = await loadImage(maskSource);
+
+  const canvas = createCanvas(img.width, img.height);
+  const ctx = canvas.getContext("2d") as SKRSContext2D;
+
+  ctx.drawImage(img, 0, 0, img.width, img.height);
+
+  const maskCanvas = createCanvas(img.width, img.height);
+  const maskCtx = maskCanvas.getContext("2d") as SKRSContext2D;
+  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: string | Buffer | PathLike | Uint8Array, 
+  options: BlendOptions
+): Promise<Buffer> {
+  const img = await loadImage(source);
+  const canvas = createCanvas(img.width, img.height);
+  const ctx = canvas.getContext("2d") as SKRSContext2D;
+
+  ctx.drawImage(img, 0, 0, img.width, img.height);
+
+  let gradient: CanvasGradient;
+  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 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: Frame[],
@@ -967,7 +1134,7 @@ async animate(
       }
 
       if (frame.pattern) {
-          const patternImage = await loadImage(frame.pattern.imagePath);
+          const patternImage = await loadImage(frame.pattern.source);
           const pattern = ctx.createPattern(patternImage, frame.pattern.repeat || 'repeat');
           fillStyle = pattern;
       }
@@ -981,8 +1148,8 @@ async animate(
           ctx.fillRect(0, 0, width, height);
       }
 
-      if (frame.imagePath) {
-          const image = await loadImage(frame.imagePath);
+      if (frame.source) {
+          const image = await loadImage(frame.source);
           ctx.globalCompositeOperation = frame.blendMode || 'source-over';
           ctx.drawImage(image, 0, 0, width, height);
       }
@@ -1019,6 +1186,8 @@ async animate(
   return options?.gif ? undefined : buffers;
 }
 
+
+
 public validHex(hexColor: string): any {
     const hexPattern = /^#[0-9a-fA-F]{6}$/;
     if (!hexPattern.test(hexColor)) {