@shibam/sticker-maker 1.2.16 → 1.3.0-rc1

package/package.json

@@ -1,51 +1,31 @@
-{
-  "name": "@shibam/sticker-maker",
-  "version": "1.2.16",
-  "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": "^2.11.2",
-    "file-type": "^20.0.0",
-    "fluent-ffmpeg": "^2.1.3",
-    "fs-extra": "^11.3.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"
-  }
-}
+{
+  "name": "@shibam/sticker-maker",
+  "version": "1.3.0-rc1",
+  "description": "A package for creating stickers",
+  "main": "dist/index.js",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {},
+  "author": "Shibam Dey",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShibamDey69/Sticker-Maker.git"
+  },
+  "keywords": [
+    "stickers",
+    "sticker maker",
+    "image processing",
+    "wa sticker maker",
+    "wasticker",
+    "nodejs",
+    "typescript"
+  ],
+  "dependencies": {
+    "file-type": "^19.4.0",
+    "fs-extra": "^11.3.5",
+    "node-webpmux": "^3.2.0"
+  }
+}

package/dist/index.js

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

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

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

@@ -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,62 +0,0 @@
-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=15';
-            // Process video with ffmpeg
-            await new Promise((resolve, reject) => {
-                ffmpeg(inputFile)
-                    .inputFormat(extType)
-                    .outputOptions([
-                    '-vf', shape,
-                    '-loop', '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

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

@@ -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 {};