@shibam/sticker-maker 1.2.13 → 1.2.15

package/dist/index.js

@@ -0,0 +1,156 @@
+import fs from 'fs-extra';
+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';
+/**
+ * Sticker class for handling sticker creation, conversion, and metadata management
+ */
+class Sticker {
+    utils;
+    buffer;
+    outBuffer;
+    mimeType;
+    extType;
+    isBufferProcessed;
+    isMetaProcessed;
+    data;
+    metaInfo;
+    /**
+     * Creates a new Sticker instance
+     * @param data The input data (Buffer, string path, or Readable stream)
+     * @param metaInfo Optional metadata and configuration
+     */
+    constructor(data, metaInfo = {}) {
+        this.utils = new Utils();
+        this.buffer = Buffer.from([]);
+        this.outBuffer = Buffer.from([]);
+        this.mimeType = '';
+        this.extType = '';
+        this.isBufferProcessed = false;
+        this.isMetaProcessed = false;
+        this.data = data;
+        this.metaInfo = this.initializeMetaInfo(metaInfo);
+    }
+    /**
+     * Initialize default metadata values
+     */
+    initializeMetaInfo(metaInfo) {
+        return {
+            pack: '',
+            author: '',
+            type: StickerTypes.DEFAULT,
+            quality: 100,
+            background: '#FFFFFF00',
+            text: '',
+            ...metaInfo,
+            // Ensure categories is always an array
+            categories: metaInfo.categories || []
+        };
+    }
+    /**
+     * Initialize the Sticker instance with file data and metadata
+     */
+    async initialize() {
+        try {
+            // Convert input to buffer
+            this.buffer = await this.utils.buffer(this.data);
+            // Get file type information
+            const fileType = await this.utils.getMimeType(this.buffer);
+            if (!fileType) {
+                throw new Error('Unable to determine file type');
+            }
+            this.mimeType = fileType.mime;
+            this.extType = fileType.ext;
+            // Set dynamic metadata values if not provided
+            this.metaInfo = {
+                ...this.metaInfo,
+                id: this.metaInfo.id ?? this.utils.getId(),
+                quality: this.metaInfo.quality ?? this.utils.getQuality(this.buffer)
+            };
+        }
+        catch (error) {
+            throw new Error(`Initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Convert input data to WebP buffer with metadata
+     */
+    async toBuffer() {
+        try {
+            await this.initialize();
+            // Convert to WebP
+            const convertedBuffer = await convert({
+                buffer: this.buffer,
+                metaInfo: {
+                    ...this.metaInfo,
+                    categories: this.metaInfo.categories // Map categories to category for compatibility
+                },
+                mimeExt: this.extType,
+                mimeType: this.mimeType
+            });
+            // Add metadata
+            this.outBuffer = await new MetaInfoChanger({
+                ...this.metaInfo,
+                categories: this.metaInfo.categories
+            }).add(convertedBuffer);
+            this.isBufferProcessed = true;
+            return this.outBuffer;
+        }
+        catch (error) {
+            this.isBufferProcessed = false;
+            throw new Error(`Buffer conversion failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Save the sticker to a file
+     */
+    async toFile(outputPath) {
+        try {
+            // Process buffer if needed
+            if (!this.isBufferProcessed && !this.isMetaProcessed && this.extType?.includes('webp')) {
+                await this.changeMetaInfo();
+            }
+            else {
+                await this.toBuffer();
+            }
+            // Write to file
+            await fs.writeFile(outputPath, this.outBuffer);
+        }
+        catch (error) {
+            throw new Error(`File conversion failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Update sticker metadata
+     */
+    async changeMetaInfo() {
+        try {
+            await this.initialize();
+            this.outBuffer = await new MetaInfoChanger({
+                ...this.metaInfo,
+                categories: this.metaInfo.categories
+            }).add(this.buffer);
+            this.isMetaProcessed = true;
+            return this.outBuffer;
+        }
+        catch (error) {
+            this.isMetaProcessed = false;
+            throw new Error(`Metadata update failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Extract metadata from a buffer
+     */
+    async extractMetaData(data) {
+        try {
+            await this.initialize();
+            return extractMetaData(data);
+        }
+        catch (error) {
+            throw new Error(`Metadata extraction failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+export { Sticker, StickerTypes };

package/dist/lib/ToWebp.js

@@ -0,0 +1,76 @@
+import sharp from 'sharp';
+import { StickerTypes } from '../types/StickerTypes.js';
+import toGif from './toGif.js';
+import TextOnImg from './textOnImg.js';
+/**
+ * Converts media (image/video) to WebP format with optional transformations
+ * @param options Configuration options for the conversion
+ * @returns Promise<Buffer> The resulting WebP buffer
+ */
+const ToWebp = async ({ buffer, metaInfo, mimeExt, mimeType }) => {
+    try {
+        // Return early if already in WebP format
+        if (mimeExt === 'webp') {
+            return buffer;
+        }
+        const textOnImg = new TextOnImg();
+        // Process initial buffer based on type and text requirements
+        const processedBuffer = await (async () => {
+            if (mimeType?.includes('video')) {
+                return toGif({
+                    buffer,
+                    extType: mimeExt,
+                    type: metaInfo.type || StickerTypes.DEFAULT,
+                    text: metaInfo.text ?? ''
+                });
+            }
+            if (metaInfo.text) {
+                return textOnImg.drawText(buffer, metaInfo.text);
+            }
+            return buffer;
+        })();
+        // Determine if content is animated
+        const isAnimated = mimeType?.includes('video') || mimeExt?.includes('gif');
+        // Initialize sharp with processed buffer
+        const sharpInstance = sharp(processedBuffer, { animated: isAnimated });
+        // Apply transformations based on sticker type
+        switch (metaInfo.type) {
+            case StickerTypes.CIRCLE: {
+                const circleSvg = Buffer.from('<svg width="512" height="512"><circle cx="256" cy="256" r="256" fill=""/></svg>');
+                await sharpInstance
+                    .resize(512, 512, { fit: sharp.fit.cover })
+                    .composite([{
+                        input: circleSvg,
+                        blend: 'dest-in',
+                        gravity: 'northeast',
+                        tile: true
+                    }]);
+                break;
+            }
+            case StickerTypes.SQUARE: {
+                if (!mimeType?.includes('video')) {
+                    await sharpInstance.resize(512, 512, { fit: sharp.fit.fill });
+                }
+                break;
+            }
+            default: {
+                await sharpInstance.resize(512, 512, {
+                    fit: sharp.fit.contain,
+                    background: { r: 0, g: 0, b: 0, alpha: 0 }
+                });
+            }
+        }
+        // Convert to WebP format with appropriate options
+        return sharpInstance
+            .toFormat('webp')
+            .webp({
+            quality: metaInfo.quality,
+            lossless: mimeExt.includes('gif')
+        })
+            .toBuffer();
+    }
+    catch (error) {
+        throw new Error(`WebP conversion failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+export default ToWebp;

package/dist/lib/changeMetaInfo.js

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,24 @@
+import TextOnGif from 'text-on-gif';
+const textOnGif = async (fileName, text) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const gif = new TextOnGif({
+                file_path: fileName,
+                font_size: '32px',
+                font_color: 'white',
+                font_family: 'Arial',
+                stroke_color: 'black',
+                stroke_width: 3
+            });
+            const buff = await gif.textOnGif({
+                text,
+                get_as_buffer: true
+            });
+            resolve(buff);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+export default textOnGif;

package/dist/lib/textOnImg.js

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,63 @@
+import ffmpeg from 'fluent-ffmpeg';
+import { tmpdir } from 'os';
+import fs from 'fs-extra';
+import { join } from 'path';
+import { StickerTypes } from '../types/StickerTypes.js';
+import TextOnGif from './textOnGif.js';
+/**
+ * Converts a video file to an animated GIF with optional text overlay
+ * @param options Configuration options for the conversion
+ * @returns Promise<Buffer> The resulting GIF as a buffer
+ */
+const videoToGif = async ({ buffer, extType, type, text = '', maxDuration = 7, maxRetries = 3 }) => {
+    const generateTempFilename = () => join(tmpdir(), `${Math.random().toString(36).slice(2)}`);
+    const cleanupFiles = async (...files) => {
+        await Promise.all(files.map(file => fs.unlink(file).catch(() => { })));
+    };
+    const processVideo = async (attempt) => {
+        const inputFile = `${generateTempFilename()}.${extType}`;
+        const outputFile = `${generateTempFilename()}.gif`;
+        try {
+            // Write input buffer to temporary file
+            await fs.writeFile(inputFile, buffer);
+            // Determine scaling and cropping parameters based on type
+            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';
+            // Process video with ffmpeg
+            await new Promise((resolve, reject) => {
+                ffmpeg(inputFile)
+                    .inputFormat(extType)
+                    .outputOptions([
+                    '-vf', shape,
+                    '-loop', '0',
+                    '-lossless', '0',
+                    '-t', maxDuration.toString(),
+                    '-preset', 'ultrafast'
+                ])
+                    .toFormat('gif')
+                    .save(outputFile)
+                    .on('end', () => resolve())
+                    .on('error', reject);
+            });
+            // Add text to GIF if required, or return the GIF buffer directly
+            const gifBuffer = text
+                ? await TextOnGif(outputFile, text)
+                : await fs.readFile(outputFile);
+            // Clean up temporary files
+            await cleanupFiles(inputFile, outputFile);
+            return gifBuffer;
+        }
+        catch (error) {
+            // Clean up temporary files
+            await cleanupFiles(inputFile, outputFile);
+            // Retry on failure up to the specified number of attempts
+            if (attempt < maxRetries) {
+                return processVideo(attempt + 1);
+            }
+            throw new Error(`Failed to convert video to GIF after ${maxRetries} attempts: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    return processVideo(1);
+};
+export default videoToGif;

package/dist/lib/utils.js

@@ -0,0 +1,82 @@
+import { Readable } from 'stream';
+import fs from 'fs-extra';
+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

@@ -0,0 +1,6 @@
+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

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

package/dist/types/metaInfoType.js

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

package/package.json

@@ -1,19 +1,51 @@
 {
   "name": "@shibam/sticker-maker",
-  "version": "1.2.13",
-  "main": "index.js",
+  "version": "1.2.15",
+  "description": "A package for creating stickers",
+  "main": "dist/index.js",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "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"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "",
+  "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": "^2.11.2",
     "file-type": "^20.0.0",
+    "fluent-ffmpeg": "^2.1.3",
     "fs-extra": "^11.3.0",
-    "node-webpmux": "3.1.0",
-    "sharp": "0.30.0"
+    "node-webpmux": "^3.2.0",
+    "sharp": "0.30.0",
+    "text-on-gif": "^2.0.13"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.17.14",
+    "@types/sharp": "^0.28.5",
+    "tsx": "^4.7.1",
+    "typescript": "^5.4.5"
   }
 }

package/readme.md

@@ -0,0 +1,112 @@
+# @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.

package/index.js

@@ -1,127 +0,0 @@
-import Exif from "./utils/changeMetaInfo.js";
-import MediaConverter from "./utils/convert.js";
-import extractMetadata from "./utils/extractMetaInfo.js";
-import fs from "fs-extra";
-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.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() {
-    const inputBuffer = await this.processImage(this.image);
-
-    const webpBuffer = await this.converter.convertToWebp(inputBuffer);
-
-    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/utils/changeMetaInfo.js

@@ -1,43 +0,0 @@
-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()
-        image =
-            image instanceof Image.Image
-                ? image
-                : await (async () => {
-                      const img = new Image.Image()
-                      await img.load(image)
-                      return img
-                  })();
-        image.exif = exif
-        return await image.save(null)
-    }
-}
-
-export default Exif;

package/utils/convert.js

@@ -1,87 +0,0 @@
-import { exec as execCallback } from "child_process";
-import fs from "fs-extra";
-import { tmpdir } from "os";
-import { promisify } from "util";
-import { fileTypeFromBuffer } from "file-type";
-import sharp from "sharp";
-const exec = promisify(execCallback);
-
-export default class MediaConverter {
-  constructor(options = {}) {
-    this.fps = 12;
-    this.quality = options.quality ?? 10;
-    this.width = options.width ?? 320;
-    this.mime = null;
-  }
-
-  async convertToWebp(buffer) {
-    const fileType = await fileTypeFromBuffer(buffer);
-    if (!fileType) throw new Error("Invalid file type");
-    if (fileType.ext === "webp") return buffer;
-    this.mime = fileType.mime;
-
-    if (this.mime.startsWith("video/")) {
-      const gif = await this.videoToGif(buffer);
-      return await this.ToWebp(gif);
-    } else if (this.mime === "image/gif") {
-      return await this.ToWebp(buffer);
-    } else if (this.mime.startsWith("image/")) {
-      return await this.ToWebp(buffer);
-    }
-
-    throw new Error(`Unsupported file type: ${this.mime}`);
-  }
-
-  videoToGif = async (data) => {
-    const filename = `${tmpdir()}/${Math.random().toString(36).substring(2)}`;
-    const videoPath = `${filename}.mp4`;
-    const gifPath = `${filename}.gif`;
-
-    try {
-      // Write the input video buffer to a temporary file
-      await fs.writeFile(videoPath, data);
-
-      // Execute FFmpeg command to convert video to GIF with lossless option
-      const ffmpegCmd = `ffmpeg -i "${videoPath}" -vf "fps=15,scale=320:-1:flags=lanczos" -loop 0 -lossless 0 "${gifPath}"`;
-      await exec(ffmpegCmd);
-
-      // Read the resulting GIF as a buffer
-      const gifBuffer = await fs.readFile(gifPath);
-
-      // Clean up temporary files
-      await Promise.all([
-        fs.unlink(videoPath).catch(() => {}),
-        fs.unlink(gifPath).catch(() => {}),
-      ]);
-
-      return gifBuffer;
-    } catch (error) {
-      // Clean up files in case of an error
-      await Promise.all([
-        fs.unlink(videoPath).catch(() => {}),
-        fs.unlink(gifPath).catch(() => {}),
-      ]);
-      throw new Error(`Failed to convert video to GIF: ${error.message}`);
-    }
-  };
-  async ToWebp(buffer) {
-    const fileType = await fileTypeFromBuffer(buffer);
-    if (!fileType) throw new Error("Invalid file type");
-
-    const mimeType = fileType.mime;
-    const isAnimated = mimeType?.includes("video") || mimeType?.includes("gif");
-
-    // Initialize sharp with animation support for GIFs or video frames
-    const res = sharp(buffer, { animated: isAnimated })
-      .toFormat("webp")
-      .resize(this.width, this.width, {
-        fit: sharp.fit.contain,
-        background: { r: 0, g: 0, b: 0, alpha: 0 }, // Transparent background
-      });
-    // Convert to WebP format with the specified quality
-
-    return await res
-      .webp({ quality: this.quality, lossless: false }) // Lossless for GIFs or animations
-      .toBuffer();
-  }
-}

package/utils/extractMetaInfo.js

@@ -1,10 +0,0 @@
-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