@shibam/sticker-maker 1.2.4 → 1.2.6

package/index.js

@@ -0,0 +1,130 @@
+import Exif from "./utils/changeMetaInfo.js";
+import MediaConverter from "./utils/convert.js";
+import extractMetadata from "./utils/extractMetaInfo.js";
+import * as fs from "fs";
+import { Readable } from "stream";
+
+export default class Sticker {
+  constructor(image, options = {}) {
+    this.buffer = null;
+    this.image = image;
+
+    this.pack = options.pack || "Default Pack";
+    this.author = options.author || "Unknown";
+    this.id = options.id || Math.random().toString(36).substring(2, 15);
+    this.converter = new MediaConverter({ quality: options.quality || 80 });
+
+    this.setCategories(options.category);
+    this.setQuality(options.quality);
+    this.setText(options.text);
+  }
+
+  async processImage(image) {
+    if (Buffer.isBuffer(image)) {
+      return image;
+    }
+
+    if (typeof image === "string") {
+      if (image.startsWith("http://") || image.startsWith("https://")) {
+        try {
+          const response = await fetch(image);
+          const arrayBuffer = await response.arrayBuffer();
+          return Buffer.from(arrayBuffer);
+        } catch (error) {
+          throw new Error("Failed to fetch image from URL: " + error.message);
+        }
+      }
+
+      try {
+        return await fs.promises.readFile(image);
+      } catch (error) {
+        throw new Error("Failed to read image file: " + error.message);
+      }
+    }
+
+    if (image instanceof Readable) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        image.on("data", (chunk) => chunks.push(chunk));
+        image.on("end", () => resolve(Buffer.concat(chunks)));
+        image.on("error", reject);
+      });
+    }
+
+    throw new Error(
+      "Invalid image input. Must be Buffer, URL, file path, or ReadableStream"
+    );
+  }
+
+  setCategories(categories) {
+    if (!categories) {
+      this.category = [];
+      return;
+    }
+
+    if (!Array.isArray(categories)) {
+      throw new Error("Categories must be an array of emoji strings");
+    }
+
+    const emojiRegex = /\p{Emoji}/u;
+    categories.forEach((category) => {
+      if (!emojiRegex.test(category)) {
+        throw new Error(`Invalid emoji category: ${category}`);
+      }
+    });
+
+    this.category = categories;
+  }
+
+  setQuality(quality) {
+    if (quality === undefined) {
+      this.quality = 100;
+      return;
+    }
+
+    if (typeof quality !== "number" || quality < 0 || quality > 100) {
+      throw new Error("Quality must be a number between 0 and 100");
+    }
+
+    this.quality = quality;
+  }
+
+  setText(text) {
+    if (text && typeof text !== "string") {
+      throw new Error("Text must be a string");
+    }
+
+    this.text = text || null;
+  }
+
+  async build() {
+    // Process input to buffer
+    const inputBuffer = await this.processImage(this.image);
+
+    // Convert to WebP using imported converter
+    const webpBuffer = await this.converter.convertToWebp(inputBuffer);
+
+    // Add metadata using imported Exif handler
+    const exif = new Exif({
+      id: this.id,
+      pack: this.pack,
+      author: this.author,
+      category: this.category,
+    });
+
+    this.buffer = await exif.add(webpBuffer);
+    return this.buffer;
+  }
+
+  async toBuffer() {
+    return await this.build();
+  }
+
+    async metadata() {
+        if (!this.buffer) {
+            await this.build();
+        }
+    
+        return await extractMetadata(this.buffer);
+    }
+}

package/package.json

@@ -1,48 +1,20 @@
-{
-  "name": "@shibam/sticker-maker",
-  "version": "1.2.4",
-  "description": "A package for creating stickers",
-  "main": "dist/index.js",
-  "type": "module",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p .",
-    "lint": "eslint \"src/**/*.ts\"",
-    "prepublish": "npm run build",
-    "fmt": "prettier --config .prettierrc \"**/*.{ts,mjs}\" --write",
-    "test": "mocha --timeout 60000 -r ts-node/register \"tests/**/*.test.ts\"",
-    "clean:webp": "find ./ -name '*.webp' -delete",
-    "release": "release-it"
-  },
-  "author": "Shibam Dey",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ShibamDey69/Sticker-Maker.git"
-  },
-  "keywords": [
-    "stickers",
-    "sticker maker",
-    "image processing",
-    "wa sticker maker",
-    "wasticker",
-    "nodejs",
-    "typescript"
-  ],
-  "dependencies": {
-    "canvas": "^3.0.1",
-    "file-type": "^20.0.0",
-    "fluent-ffmpeg": "^2.1.3",
-    "node-webpmux": "^3.2.0",
-    "sharp": "^0.33.5"
-  },
-  "devDependencies": {
-    "@types/fluent-ffmpeg": "^2.1.24",
-    "@types/node": "^20.17.14",
-    "@types/sharp": "^0.28.5",
-    "tsx": "^4.7.1",
-    "typescript": "^5.4.5"
-  }
-}
+{
+  "name": "@shibam/sticker-maker",
+  "version": "1.2.6",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "cwebp": "^3.1.0",
+    "file-type": "^20.0.0",
+    "jimp": "^1.6.0",
+    "node-webpmux": "^3.2.0",
+    "webp-converter": "^2.3.3"
+  }
+}

package/test/index.js

@@ -0,0 +1,11 @@
+import Sticker from '../index.js';
+import * as fs from 'fs';
+const sticker = new Sticker('./test/lol.mp4',{
+    pack: 'My Pack',
+    author: 'Me',
+    category: ['😹'],
+    quality: 80,
+    text: 'Hello World'
+});
+sticker.metadata().then(console.log);
+fs.writeFileSync('sticker.webp', await sticker.build());

package/utils/changeMetaInfo.js

@@ -0,0 +1,43 @@
+import Image from "node-webpmux"
+import { TextEncoder } from "util";
+
+class Exif {
+    constructor(options = {}) {
+        this.data = {
+            'sticker-pack-id': options.id || '',
+            'sticker-pack-name': options.pack || '',
+            'sticker-pack-publisher': options.author || '',
+            'emojis': options.category || ['😹']
+        };
+        this.exif = null;
+    }
+
+    build() {
+        const data = JSON.stringify(this.data);
+        const exif = Buffer.concat([
+            Buffer.from([
+                0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x16, 0x00, 0x00, 0x00
+            ]),
+            Buffer.from(data, 'utf-8')
+        ]);
+        exif.writeUIntLE(new TextEncoder().encode(data).length, 14, 4);
+        return exif;
+    }
+
+    async add(image) {
+        const exif = this.exif || this.build();
+
+        if (image instanceof Image.Image) {
+            image.exif = exif;
+            return await image.save(null);
+        }
+
+        const img = new Image.Image();
+        await img.load(image);
+        img.exif = exif;
+        return await img.save(null);
+    }
+}
+
+export default Exif;

package/utils/convert.js

@@ -0,0 +1,105 @@
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+import { promises as fs } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { fileTypeFromBuffer } from "file-type";
+
+
+const exec = promisify(execCallback);
+
+export default class MediaConverter {
+  constructor(options = {}) {
+    this.fps = options.fps || 12;
+    this.quality = options.quality || 80;
+    this.width = options.width || 512;
+    this.mime = null;
+  }
+
+  async convertToWebp(buffer) {
+    const fileType = await fileTypeFromBuffer(buffer);
+    if (!fileType) throw new Error("Invalid file type");
+
+    this.mime = fileType.mime;
+
+    if (this.mime.startsWith("video/")) {
+      const gif = await this.videoToGif(buffer);
+      return await this.gifToWebp(gif);
+    } else if (this.mime === "image/gif") {
+      return await this.gifToWebp(buffer);
+    } else if (this.mime.startsWith("image/")) {
+      return await this.imageToWebp(buffer);
+    }
+
+    throw new Error(`Unsupported file type: ${this.mime}`);
+  }
+
+  async videoToGif(buffer) {
+    const tempInput = join(tmpdir(), `input_${Date.now()}.mp4`);
+    const tempOutput = join(tmpdir(), `output_${Date.now()}.gif`);
+
+    try {
+      await fs.writeFile(tempInput, buffer);
+
+      const ffmpegCmd = `ffmpeg -i "${tempInput}" -vf "fps=${this.fps},scale=${this.width}:-1:flags=lanczos" -loop 0 -lossless 0 -t 7 -preset ultrafast -f gif "${tempOutput}"`;
+      await exec(ffmpegCmd);
+
+      const gifBuffer = await fs.readFile(tempOutput);
+
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+
+      return gifBuffer;
+    } catch (error) {
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+      throw new Error(`Failed to convert video to gif: ${error.message}`);
+    }
+  }
+
+  async gifToWebp(buffer) {
+    const tempInput = join(tmpdir(), `input_${Date.now()}.gif`);
+    const tempOutput = join(tmpdir(), `output_${Date.now()}.webp`);
+
+    try {
+      await fs.writeFile(tempInput, buffer);
+
+      // Use gif2webp to convert GIF to WebP
+      const gif2webpCmd = `gif2webp "${tempInput}" -q ${this.quality} -o "${tempOutput}"`;
+      await exec(gif2webpCmd);
+
+      const webpBuffer = await fs.readFile(tempOutput);
+
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+
+      return webpBuffer;
+    } catch (error) {
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+      throw new Error(`Failed to convert gif to webp: ${error.message}`);
+    }
+  }
+
+  async imageToWebp(buffer) {
+    const tempInput = join(tmpdir(), `input_${Date.now()}.png`);
+    const tempOutput = join(tmpdir(), `output_${Date.now()}.webp`);
+
+    try {
+      // Write the input buffer to a temporary file
+      await fs.writeFile(tempInput, buffer);
+
+      // Use cwebp to convert the image to WebP
+      const cwebpCmd = `cwebp "${tempInput}" -q ${this.quality} -o "${tempOutput}"`;
+      await exec(cwebpCmd);
+
+      // Read the resulting WebP file as a buffer
+      const webpBuffer = await fs.readFile(tempOutput);
+
+      // Clean up temporary files
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+
+      return webpBuffer;  // Return the WebP buffer as output
+    } catch (error) {
+      // Clean up temporary files in case of error
+      await Promise.all([fs.unlink(tempInput).catch(() => {}), fs.unlink(tempOutput).catch(() => {})]);
+      throw new Error(`Failed to convert image to webp: ${error.message}`);
+    }
+  }
+}

package/utils/extractMetaInfo.js

@@ -0,0 +1,10 @@
+import Image from 'node-webpmux'
+
+const extractMetadata = async (image) => {
+    const img = new Image.Image()
+    await img.load(image)
+    const exif = img.exif?.toString('utf-8') ?? '{}'
+    return JSON.parse(exif.substring(exif.indexOf('{'), exif.lastIndexOf('}') + 1) ?? '{}')
+}
+
+export default extractMetadata

package/dist/index.js

@@ -1,119 +0,0 @@
-import * as fs from 'fs';
-import Utils from './lib/utils.js';
-import convert from './lib/ToWebp.js';
-import { StickerTypes } from './types/StickerTypes.js';
-import MetaInfoChanger from './lib/changeMetaInfo.js';
-import extractMetaData from './lib/extractMetaData.js';
-class Sticker {
-    data;
-    metaInfo;
-    buffer;
-    mimeType;
-    extType;
-    utils = new Utils();
-    outBuffer;
-    activeBuff;
-    activeMeta;
-    constructor(data, metaInfo = {}) {
-        this.data = data;
-        this.metaInfo = metaInfo;
-        this.buffer = Buffer.from([]);
-        this.outBuffer = Buffer.from([]);
-        this.activeBuff = false;
-        this.activeMeta = false;
-        this.mimeType = '';
-        this.extType = '';
-    }
-    /**
-     * Initializes the Sticker instance.
-     * - Sets default values for metaInfo.
-     * - Reads and analyzes input data to determine MIME type and extension type.
-     * - Generates ID and quality metadata if not provided.
-     */
-    async initialize() {
-        try {
-            this.buffer = await this.utils.buffer(this.data);
-            const fileType = await this.utils.getMimeType(this.buffer);
-            this.mimeType = fileType?.mime ?? '';
-            this.extType = fileType?.ext ?? '';
-            this.metaInfo.pack = this.metaInfo.pack ?? '';
-            this.metaInfo.author = this.metaInfo.author ?? '';
-            this.metaInfo.id = this.metaInfo.id ?? this.utils.getId();
-            this.metaInfo.category = this.metaInfo.category ?? [];
-            this.metaInfo.type = this.metaInfo.type ?? StickerTypes.DEFAULT;
-            this.metaInfo.quality = this.metaInfo?.quality ?? this.utils.getQuality(this.buffer);
-            this.metaInfo.text = this.metaInfo.text ?? '';
-        }
-        catch (error) {
-            throw new Error(`Initialization error: ${error}`);
-        }
-    }
-    /**
-     * Converts input data to a Buffer containing the converted content.
-     * @returns Promise<Buffer> A Promise resolving to the converted content as Buffer.
-     */
-    async toBuffer() {
-        try {
-            await this.initialize();
-            const buffer = await convert(this.buffer, this.metaInfo, this.extType, this.mimeType);
-            this.outBuffer = await new MetaInfoChanger(this.metaInfo).add(buffer);
-            this.activeBuff = true;
-            return this.outBuffer;
-        }
-        catch (error) {
-            this.activeBuff = false;
-            throw new Error(`Conversion to buffer failed: ${error}`);
-        }
-    }
-    /**
-     * Converts input data and writes it to a file at the specified outputPath.
-     * @param outputPath The path where the converted file will be saved.
-     * @returns Promise<void> A Promise resolving when the file is successfully written.
-     */
-    async toFile(outputPath) {
-        try {
-            if (!this.activeBuff && !this.activeMeta && this.extType?.includes('webp')) {
-                await this.changeMetaInfo();
-            }
-            else {
-                await this.toBuffer();
-            }
-            await fs.promises.writeFile(outputPath, this.outBuffer);
-        }
-        catch (error) {
-            throw new Error(`Conversion to file failed: ${error}`);
-        }
-    }
-    /**
-     * Changes the metadata of the sticker.
-     * @param newMetaInfo Partial metadata to update.
-     * @returns Promise<Buffer> A Promise resolving to the Buffer with updated metadata.
-     */
-    async changeMetaInfo() {
-        try {
-            await this.initialize();
-            this.outBuffer = await new MetaInfoChanger(this.metaInfo).add(this.buffer);
-            this.activeMeta = true;
-            return this.outBuffer;
-        }
-        catch (error) {
-            this.activeMeta = false;
-            throw new Error(`Error changing meta info: ${error}`);
-        }
-    }
-    /**
-     * Extracts metadata from the provided data.
-     * @param data Buffer containing the data to extract metadata from.
-     * @returns Promise<Partial<MetaDataType>> A Promise resolving to the extracted metadata.
-     */
-    async extractMetaData(data) {
-        try {
-            await this.initialize();
-            return extractMetaData(data);
-        }
-        catch (error) {
-            throw new Error(`Error extracting meta data: ${error}`);
-        }
-    }
-}
-export { Sticker, StickerTypes };

package/dist/lib/ToWebp.js

@@ -1,61 +0,0 @@
-import sharp from 'sharp';
-import { StickerTypes } from '../types/StickerTypes.js';
-import toGif from './toGif.js';
-import TextOnImg from './textOnImg.js';
-const textOnImg = new TextOnImg();
-/**
- * Converts a given buffer to WebP format with optional transformations.
- *
- * @param {Buffer} buffer - The input buffer to be converted.
- * @param {Partial<MetaDataType>} metaInfo - Metadata information for the conversion.
- * @param {string} mimeExt - The MIME extension of the input buffer.
- * @param {string} mimeType - The MIME type of the input buffer.
- * @returns {Promise<Buffer>} - A promise that resolves to the converted WebP buffer.
- */
-const ToWebp = async (buffer, metaInfo, mimeExt, mimeType) => {
-    try {
-        if (mimeExt === 'webp')
-            return buffer;
-        let data = (mimeType?.includes('video')
-            ? await toGif(buffer, mimeExt, metaInfo.type || StickerTypes.DEFAULT, metaInfo.text ?? '')
-            : metaInfo.text
-                ? await textOnImg.drawText(buffer, metaInfo.text)
-                : buffer);
-        let isAnimated = mimeType?.includes('video') || mimeExt?.includes('gif');
-        const res = sharp(data, { animated: isAnimated });
-        if (metaInfo.type === StickerTypes.CIRCLE) {
-            res.resize(512, 512, {
-                fit: sharp.fit.cover
-            }).composite([
-                {
-                    input: Buffer.from(`<svg width="512" height="512"><circle cx="256" cy="256" r="256" fill=""/></svg>`),
-                    blend: 'dest-in',
-                    gravity: 'northeast',
-                    tile: true
-                }
-            ]);
-        }
-        else if (metaInfo.type === StickerTypes.SQUARE && !mimeType?.includes('video')) {
-            res.resize(512, 512, {
-                fit: sharp.fit.fill
-            });
-        }
-        else {
-            res.resize(512, 512, {
-                fit: sharp.fit.contain,
-                background: { r: 0, g: 0, b: 0, alpha: 0 }
-            });
-        }
-        return res
-            .toFormat('webp')
-            .webp({
-            quality: metaInfo.quality,
-            lossless: mimeExt.includes('gif') ? true : false
-        })
-            .toBuffer();
-    }
-    catch (error) {
-        throw new Error(`Conversion failed: ${error}`);
-    }
-};
-export default ToWebp;

package/dist/lib/changeMetaInfo.js

@@ -1,56 +0,0 @@
-import Image from 'node-webpmux';
-import { TextEncoder } from 'util';
-/**
- * The Exif class is responsible for handling the metadata (Exif data)
- * for sticker images, particularly those used in messaging applications.
- */
-export default class Exif {
-    data = {};
-    exif = null;
-    /**
-     * Constructs an Exif instance with the given options.
-     * @param options - An object containing metadata for the sticker.
-     */
-    constructor(options) {
-        this.data['sticker-pack-id'] = options.id || '';
-        this.data['sticker-pack-name'] = options.pack || '';
-        this.data['sticker-pack-publisher'] = options.author || '';
-        this.data['emojis'] = options.category || ['😹'];
-    }
-    /**
-     * Builds the Exif metadata as a Buffer.
-     * @returns A Buffer containing the constructed Exif data.
-     */
-    build = () => {
-        const data = JSON.stringify(this.data);
-        const exif = Buffer.concat([
-            Buffer.from([
-                0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x16, 0x00, 0x00, 0x00
-            ]),
-            Buffer.from(data, 'utf-8')
-        ]);
-        exif.writeUIntLE(new TextEncoder().encode(data).length, 14, 4);
-        return exif;
-    };
-    /**
-     * Adds the Exif metadata to the given image.
-     * @param image - A Buffer or Image instance representing the image to which Exif data should be added.
-     * @returns A Promise that resolves to a Buffer containing the image with the added Exif data.
-     */
-    add = async (image) => {
-        const exif = this.exif || this.build();
-        // Load the image if it is not already an instance of Image.Image.
-        image =
-            image instanceof Image.Image
-                ? image
-                : await (async () => {
-                    const img = new Image.Image();
-                    await img.load(image);
-                    return img;
-                })();
-        // Set the Exif data on the image and save it.
-        image.exif = exif;
-        return await image.save(null);
-    };
-}

package/dist/lib/extractMetaData.js

@@ -1,12 +0,0 @@
-import Image from 'node-webpmux';
-/**
- * Extracts metadata from a WebP image.
- * @param {Buffer}image - The image buffer to extract metadata from
- */
-const extractMetadata = async (image) => {
-    const img = new Image.Image();
-    await img.load(image);
-    const exif = img.exif?.toString('utf-8') ?? '{}';
-    return JSON.parse(exif.substring(exif.indexOf('{'), exif.lastIndexOf('}') + 1) ?? '{}');
-};
-export default extractMetadata;

package/dist/lib/textOnGif.js

@@ -1,13 +0,0 @@
-import * as fs from "fs/promises";
-const textOnGif = async (fileName, text) => {
-    return new Promise(async (resolve, reject) => {
-        try {
-            let buff = await fs.readFile(fileName);
-            resolve(buff);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-};
-export default textOnGif;

package/dist/lib/textOnImg.js

@@ -1,62 +0,0 @@
-import { createCanvas, loadImage } from 'canvas';
-export default class TextOnImage {
-    fontSize;
-    maxCharsPerLine;
-    constructor(maxCharsPerLine = 25) {
-        this.fontSize = 175;
-        this.maxCharsPerLine = maxCharsPerLine;
-    }
-    wrapText(ctx, text) {
-        const words = text.split(' ');
-        let lines = [];
-        let currentLine = words[0];
-        for (let i = 1; i < words.length; i++) {
-            const word = words[i];
-            const testLine = `${currentLine} ${word}`;
-            const { width: testWidth } = ctx.measureText(testLine);
-            if (testWidth > ctx.canvas.width * 0.9) {
-                lines.push(currentLine);
-                currentLine = word;
-            }
-            else {
-                currentLine = testLine;
-            }
-        }
-        lines.push(currentLine);
-        return lines;
-    }
-    async drawText(imageBuffer, text, padding = { x: 10, y: 10 }) {
-        const image = await loadImage(imageBuffer);
-        const canvas = createCanvas(image.width, image.height);
-        const ctx = canvas.getContext('2d');
-        // Draw the image on canvas
-        ctx.drawImage(image, 0, 0);
-        // Calculate font size based on image height
-        this.fontSize = Math.floor(image.height / 10);
-        ctx.font = `bold ${this.fontSize}px Arial`;
-        ctx.fillStyle = 'white';
-        ctx.textAlign = 'center';
-        ctx.textBaseline = 'top';
-        ctx.lineWidth = 4;
-        ctx.strokeStyle = 'black';
-        // Wrap the text to fit within the canvas width
-        const lines = this.wrapText(ctx, text);
-        const lineHeight = this.fontSize * 1.2;
-        const totalTextHeight = lines.length * lineHeight;
-        // If text height exceeds image height, adjust font size
-        if (totalTextHeight + 2 * padding.y > canvas.height) {
-            this.fontSize = Math.floor((canvas.height - 2 * padding.y) / (lines.length * 1.2));
-            ctx.font = `bold ${this.fontSize}px Arial`;
-        }
-        // Start text positioning at the bottom, above padding
-        let y = canvas.height - totalTextHeight - padding.y;
-        // Draw each line of text with stroke and fill for better contrast
-        lines.forEach((line) => {
-            const x = canvas.width / 2;
-            ctx.strokeText(line, x, y);
-            ctx.fillText(line, x, y);
-            y += lineHeight;
-        });
-        return canvas.toBuffer('image/png');
-    }
-}

package/dist/lib/toGif.js

@@ -1,55 +0,0 @@
-import ffmpeg from 'fluent-ffmpeg';
-import { tmpdir } from 'os';
-import { writeFile, readFile, unlink } from 'fs/promises';
-import { join } from 'path';
-import { StickerTypes } from '../types/StickerTypes.js';
-import TextOnGif from './textOnGif.js';
-const videoToGif = (buffer, extType, type, text = '') => {
-    return new Promise(async (resolve, reject) => {
-        const execute = async (attempt) => {
-            const filename = join(tmpdir(), `${Math.random().toString(36)}.${extType}`);
-            const outputFilename = join(tmpdir(), `${Math.random().toString(36)}.gif`);
-            const retries = 3;
-            try {
-                await writeFile(filename, buffer);
-                const shape = type === StickerTypes.SQUARE
-                    ? 'scale=320:-1:flags=lanczos,fps=10,crop=min(iw\\,ih):min(iw\\,ih)'
-                    : 'scale=320:-1:flags=lanczos,fps=20';
-                await new Promise((resolveFfmpeg, rejectFfmpeg) => {
-                    ffmpeg(filename)
-                        .inputFormat(extType)
-                        .outputOptions([
-                        '-vf',
-                        shape,
-                        '-loop',
-                        '0',
-                        '-lossless',
-                        '0',
-                        '-t',
-                        '7',
-                        '-preset',
-                        'ultrafast'
-                    ])
-                        .toFormat('gif')
-                        .save(outputFilename)
-                        .on('end', resolveFfmpeg)
-                        .on('error', rejectFfmpeg);
-                });
-                const gifBuffer = text ? await TextOnGif(outputFilename, text) : await readFile(outputFilename);
-                await Promise.all([unlink(filename), unlink(outputFilename)]);
-                resolve(gifBuffer);
-            }
-            catch (error) {
-                if (attempt < retries) {
-                    execute(++attempt);
-                }
-                else {
-                    await Promise.all([unlink(filename).catch(() => { }), unlink(outputFilename).catch(() => { })]);
-                    reject(error);
-                }
-            }
-        };
-        execute(1);
-    });
-};
-export default videoToGif;

package/dist/lib/utils.js

@@ -1,82 +0,0 @@
-import { Readable } from 'stream';
-import * as fs from 'fs';
-export default class Utils {
-    constructor() { }
-    /**
-     * Converts various types of input data to a Buffer.
-     * @param data Input data as Buffer, string (file path), or Readable stream.
-     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
-     * @throws Error if conversion fails.
-     */
-    async buffer(data) {
-        try {
-            const buffer = typeof data === 'string'
-                ? await fs.promises.readFile(data)
-                : data instanceof Readable
-                    ? await this.streamToBuffer(data)
-                    : Buffer.from(data);
-            return buffer;
-        }
-        catch (error) {
-            throw new Error(`Error converting to buffer: ${error}`);
-        }
-    }
-    /**
-     * Converts a Readable stream to a Buffer.
-     * @param stream Readable stream to convert.
-     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
-     */
-    async streamToBuffer(stream) {
-        const chunks = [];
-        return new Promise((resolve, reject) => {
-            stream.on('data', (chunk) => {
-                if (Buffer.isBuffer(chunk)) {
-                    chunks.push(chunk);
-                }
-                else {
-                    chunks.push(Buffer.from(chunk));
-                }
-            });
-            stream.on('end', () => {
-                resolve(Buffer.concat(chunks));
-            });
-            stream.on('error', (err) => {
-                reject(err);
-            });
-        });
-    }
-    /**
-     * Determines the quality of the data based on its size.
-     * @param data Buffer containing the data.
-     * @returns number Quality value based on data size.
-     */
-    getQuality(data) {
-        let buffer = Buffer.from(data);
-        let bytes = buffer.length / 1024;
-        let quality = bytes > 4 * 1024 ? 8 : bytes > 3 * 1024 ? 10 : bytes > 2 * 1024 ? 12 : 15;
-        return quality;
-    }
-    /**
-     * Determines the MIME type of the data buffer.
-     * @param data Buffer containing the data.
-     * @returns Promise<{ mime: string; ext: string }> A Promise resolving to an object with MIME type and extension.
-     */
-    async getMimeType(data) {
-        try {
-            const { fileTypeFromBuffer } = await import('file-type');
-            const fileType = await fileTypeFromBuffer(data);
-            return fileType;
-        }
-        catch (error) {
-            console.error(`Error getting MIME type: ${error}`);
-            return undefined;
-        }
-    }
-    /**
-     * Generates a random ID.
-     * @returns string A random alphanumeric ID.
-     */
-    getId() {
-        return [...Array(5)].map(() => Math.random().toString(36).substring(2, 15)).join('');
-    }
-}

package/dist/types/StickerTypes.js

@@ -1,6 +0,0 @@
-export var StickerTypes;
-(function (StickerTypes) {
-    StickerTypes[StickerTypes["DEFAULT"] = 0] = "DEFAULT";
-    StickerTypes[StickerTypes["SQUARE"] = 1] = "SQUARE";
-    StickerTypes[StickerTypes["CIRCLE"] = 2] = "CIRCLE";
-})(StickerTypes || (StickerTypes = {}));

package/dist/types/categoryType.js

@@ -1 +0,0 @@
-export {};

package/dist/types/metaInfoType.js

@@ -1 +0,0 @@
-export {};

package/readme.md

@@ -1,112 +0,0 @@
-# @shibam/sticker-maker
-
-`@shibam/sticker-maker` is a lightweight utility library designed for converting images and videos into stickers while allowing customization of metadata. you have to download ffmpeg and canvas dependencies globally. It supports various input types and ensures high-quality sticker conversion. This module has minimal dependencies, ensuring efficient performance. If you encounter any issues, please feel free to open an issue. However, please check if a similar issue has already been reported before creating a new one. Happy Coding (⁠≧⁠▽⁠≦⁠).
-
-# Sticker Class
-
-The `Sticker` class is a utility for converting images and videos into sticker format, with options for metadata customization and manipulation.
-
-## Installation
-   
-You can install the package using npm:
-
-```sh
-npm install @shibam/sticker-maker
-```
-## Usage
-
-Here's how you can use the `Sticker` class:
-
-```typescript
-import fs from "fs";
-import { Readable } from "stream";
-import { Sticker, StickerTypes } from "@shibam/sticker-maker";
-
-// Example 1: Create a new sticker instance and convert to buffer
-const sticker = new Sticker("path/to/image.png", {
-  pack: "My Sticker Pack",
-  author: "Shibam",
-  id: "123467890",
-  category: ['😂','😹'],
-  type: StickerTypes.DEFAULT,
-  quality: 30,
-  text:"hello baka!" // if you want to use this download canvas dependecies
-});
-
-try {
-  const buffer = await sticker.toBuffer();
-  console.log("Sticker converted to buffer:", buffer);
-} catch (error) {
-  console.error("Error converting sticker to buffer:", error);
-}
-
-// Example 2: Create a new sticker instance and convert to file
-const sticker2 = new Sticker("path/to/another/image.png", {
-  pack: "Another Sticker Pack",
-  author: "John Doe",
-  id: "987654321",
-  category: ['😊','👍'],
-  type: StickerTypes.CIRCLE,
-  quality: 50,
-  text:"hello baka!" // if you want to use this download canvas dependecies
-});
-
-try {
-  await sticker2.toFile("path/to/output.webp");
-  console.log("Sticker converted and saved to file successfully.");
-} catch (error) {
-  console.error("Error converting sticker to file:", error);
-}
-```
-
-## Class: `Sticker`
-
-### Constructor
-
-```typescript
-new Sticker(data: Buffer | string | Readable, metaInfo?: Partial<MetaDataType>)
-```
-
-- `data`: Input data for the sticker. Can be a Buffer, file path as a string, or Readable stream.
-- `metaInfo` (optional): Metadata about the sticker.
-
-### Methods
-
-#### `toBuffer(): Promise<Buffer>`
-
-Converts input data to a Buffer containing the converted sticker content.
-
-#### `toFile(outputPath: string): Promise<void>`
-
-Converts input data and writes the converted sticker to a file at `outputPath`.
-
-
-#### `extractMetaData(data: Buffer): Promise<any>`
-
-Extracts metadata from `data` and returns the extracted information.
-
-## Types
-
-### `StickerTypes`
-
-An enum specifying different types of stickers:
-
-```typescript
-enum StickerTypes {
-  DEFAULT,
-  CIRCLE,
-  SQUARE,
-}
-```
-
-## License
-
-This package is licensed under the MIT License.
-
-## Contributing
-
-Contributions are welcome. Feel free to open issues or submit pull requests on [GitHub](https://github.com/NekoSenpai69/Sticker-Maker).
-
----
-
-This README provides an overview of the `Sticker` class functionalities, installation instructions, examples of usage, information about types used, and guidelines for contributing to the project. Adjust paths and additional details based on your actual implementation and repository setup.