@shibam/sticker-maker 1.1.11 → 1.1.13

package/dist/index.js

@@ -42,6 +42,7 @@ class Sticker {
             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}`);

package/dist/lib/ToWebp.js

@@ -1,6 +1,8 @@
 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.
  *
@@ -15,8 +17,8 @@ const ToWebp = async (buffer, metaInfo, mimeExt, mimeType) => {
         if (mimeExt === 'webp')
             return buffer;
         let data = mimeType?.includes('video')
-            ? await toGif(buffer, mimeExt, metaInfo.type || StickerTypes.DEFAULT)
-            : buffer;
+            ? 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) {

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: "18px",
+                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,54 @@
+import { createCanvas, loadImage } from 'canvas';
+export default class TextOnImage {
+    fontSize;
+    maxCharsPerLine;
+    constructor(maxCharsPerLine = 33) {
+        this.fontSize = 65;
+        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}`;
+            if (testLine.length > this.maxCharsPerLine) {
+                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');
+        ctx.drawImage(image, 0, 0);
+        ctx.font = `bold ${this.fontSize}px Arial`;
+        ctx.fillStyle = 'white';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'top';
+        ctx.lineWidth = 4;
+        ctx.strokeStyle = 'black';
+        const lines = this.wrapText(ctx, text);
+        const lineHeight = this.fontSize * 1.2;
+        const totalTextHeight = lines.length * lineHeight;
+        if (totalTextHeight + (2 * padding.y) > canvas.height) {
+            this.fontSize = (canvas.height - (2 * padding.y)) / (lines.length * 1.2);
+            ctx.font = `bold ${this.fontSize}px Arial`;
+        }
+        let y = canvas.height - totalTextHeight - padding.y;
+        lines.forEach(line => {
+            let 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,59 +1,41 @@
 import ffmpeg from 'fluent-ffmpeg';
 import ffmpegInstaller from '@ffmpeg-installer/ffmpeg';
-import { PassThrough } from 'stream';
+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';
 ffmpeg.setFfmpegPath(ffmpegInstaller.path);
-const videoToGif = (buffer, extType, type, retries = 3) => {
+const videoToGif = (buffer, extType, type, text = '') => {
     return new Promise(async (resolve, reject) => {
         const execute = async (attempt) => {
-            const outputStream = new PassThrough({ allowHalfOpen: false });
-            const inputStream = new PassThrough({ allowHalfOpen: false });
+            const filename = join(tmpdir(), `${Math.random().toString(36)}.${extType}`);
+            const outputFilename = join(tmpdir(), `${Math.random().toString(36)}.gif`);
+            const retries = 3;
             try {
-                const chunks = [];
-                inputStream.write(buffer);
-                inputStream.end();
-                outputStream.on('data', (chunk) => {
-                    chunks.push(chunk);
-                });
-                outputStream.on('end', () => {
-                    resolve(Buffer.concat(chunks));
-                    inputStream.destroy();
-                    outputStream.destroy();
-                });
-                const handleError = (err) => {
-                    inputStream.destroy();
-                    outputStream.destroy();
-                    if (attempt < retries) {
-                        execute(++attempt);
-                    }
-                    else {
-                        reject(err);
-                    }
-                };
-                inputStream.on('error', handleError);
-                outputStream.on('error', handleError);
+                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';
-                ffmpeg(inputStream)
-                    .inputFormat(extType)
-                    .outputOptions(['-vf', shape, '-loop', '0', '-lossless', '0', '-t', '7', '-preset', 'ultrafast'])
-                    .toFormat('gif')
-                    .pipe(outputStream)
-                    .on('error', async (err) => {
-                    if (attempt < retries) {
-                        execute(++attempt);
-                    }
-                    else {
-                        reject(err);
-                    }
+                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);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shibam/sticker-maker",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "description": "A package for creating stickers",
   "main": "dist/index.js",
   "type": "module",
@@ -35,10 +35,12 @@
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@types/fluent-ffmpeg": "^2.1.24",
+    "canvas": "^2.11.2",
     "file-type": "^19.4.0",
     "fluent-ffmpeg": "^2.1.3",
     "node-webpmux": "^3.2.0",
-    "sharp": "^0.33.4"
+    "sharp": "^0.33.4",
+    "text-on-gif": "^2.0.13"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",