@boruto_vk7/stickengine 0.0.3-alpha → 0.0.5

package/README.md

@@ -1,135 +1,121 @@
-# StickEngine
+# 🚀 StickEngine
 
-[![npm](https://img.shields.io/npm/v/@boruto_vk7/stickengine)](https://www.npmjs.com/package/@boruto_vk7/stickengine)
-[![license](https://img.shields.io/npm/l/@boruto_vk7/stickengine)](https://github.com/Borutovk7/StickEngine/blob/main/LICENSE)
+**StickEngine** é um motor poderoso e leve para criação de figurinhas do WhatsApp (estáticas e animadas) com suporte integrado a filtros de imagem, adição de texto e remoção de fundo. Projetado para funcionar em qualquer lugar, do **Termux** a servidores dedicados.
 
-Módulo Node.js para criação de stickers para WhatsApp — feito pra funcionar em qualquer lugar, do **Termux no seu celular** até um servidor dedicado. Sem dependências nativas complicadas, sem dor de cabeça na instalação.
+[![NPM Version](https://img.shields.io/npm/v/@boruto_vk7/stickengine?style=flat-square)](https://www.npmjs.com/package/@boruto_vk7/stickengine)
+[![License](https://img.shields.io/npm/l/@boruto_vk7/stickengine?style=flat-square)](https://github.com/Borutovk7/StickEngine)
 
-> Sabe aquele sofrimento de tentar rodar um módulo de sticker no Termux e quebrar tudo por causa do `sharp` ou de alguma lib nativa? O StickEngine foi criado exatamente pra resolver isso. Aqui funciona.
+---
 
-## Por que o StickEngine?
+## ✨ Funcionalidades
 
-- ✅ **Funciona no Termux** — sem `sharp`, sem compilação nativa, sem erro de permissão
-- ✅ **Funciona em VPS, Replit, Railway, servidor dedicado** — em qualquer ambiente
-- ✅ **Zero configuração extra** — instala e já usa
-- ✅ **Suporte a ESM e CJS** — compatível com qualquer projeto
-- ✅ **Entrada flexível** — URL, Buffer ou caminho local, tanto faz
+- 🎞️ **Figurinhas Animadas**: Suporte automático para GIFs e Vídeos (MP4).
+- 🎨 **Filtros Profissionais**: Sépia, Tons de Cinza, Inversão e Desfoque (Blur).
+- ✍️ **Texto Customizado**: Adicione legendas diretamente na figurinha.
+- ✂️ **Remoção de Fundo**: Integração com a API `remove.bg`.
+- 🧹 **Limpeza Automática**: Sistema de gerenciamento de arquivos temporários com o método `.clean()`.
+- 🏷️ **Metadados (Exif)**: Personalize o nome do pacote e o autor sem complicação.
+- 📱 **Termux Friendly**: Sem dependências nativas pesadas como `sharp`.
 
-## Requisitos
+---
 
-- Node.js 16+
-- [ffmpeg](https://ffmpeg.org/) instalado no sistema
+## 🖼️ Exemplos Visuais
 
-```bash
-# Termux
-pkg install ffmpeg
+| Filtro Séia + Texto | Figurinha Animada (Mockup) |
+| :---: | :---: |
+| ![Sepia Preview](assets/preview_sepia.png) | ![Animated Preview](assets/preview_animated.png) |
 
-# Debian/Ubuntu/VPS
-sudo apt install ffmpeg
-```
+---
 
-## Instalação
+## 📦 Instalação
 
 ```bash
 npm install @boruto_vk7/stickengine
 ```
 
-## Uso
+> **Requisito:** Certifique-se de ter o [FFmpeg](https://ffmpeg.org/) instalado no seu sistema. No Termux: `pkg install ffmpeg`.
+
+---
 
-### ESM
+## 🚀 Como Usar (Exemplos Técnicos)
 
+### 1. Criando uma Figurinha Estática Simples
 ```javascript
 import StickEngine from '@boruto_vk7/stickengine';
 
-const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack de Stickers',
-    author: 'Borutovk7',
-    emojis: ['✨', '🚀']
-  },
-  // Opcional: chaves da API remove.bg para remoção de fundo
-  // transparent: ['SUA_API_KEY']
-});
+const engine = new StickEngine();
+engine.addFile('https://exemplo.com/foto.jpg');
 
-engine.on('st.start', (data) => console.log(`Processando:`, data.input));
-engine.on('st.data',  (data) => console.log(`Sticker gerado:`, data.file));
-engine.on('st.error', (data) => console.error(`Erro:`, data.error));
+const results = await engine.start();
+console.log('Caminho do WebP:', results[0].value);
+engine.clean();
+```
 
-const results = await engine
-  .addFile('https://picsum.photos/512') // URL
-  .addFile('caminho/para/video.mp4')    // caminho local
-  .addFile(buffer)                      // Buffer
-  .start();
+### 2. Figurinha Animada (GIF ou Vídeo)
+O motor detecta automaticamente a duração e converte para WebP animado.
+```javascript
+const engine = new StickEngine({
+  fps: 20, // Aumenta a fluidez
+  quality: 70 // Otimiza o tamanho para o WhatsApp
+});
 
-console.log(results);
+engine.addFile('./video_engracado.mp4');
+await engine.start();
+engine.clean();
 ```
 
-### CJS
-
+### 3. Aplicando Filtros e Texto
 ```javascript
-const StickEngine = require('@boruto_vk7/stickengine');
-
 const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack',
-    author: 'Borutovk7',
-    emojis: ['🎉']
+  edit: {
+    sepia: true,
+    blur: 5,
+    text: {
+      content: 'MUITO BOM!',
+      alignmentY: 2 // 0: Topo, 1: Meio, 2: Baixo
+    }
   }
 });
 
-engine.on('st.start', (data) => console.log(`Processando:`, data.input));
-engine.on('st.data',  (data) => console.log(`Sticker gerado:`, data.file));
-engine.on('st.error', (data) => console.error(`Erro:`, data.error));
-
-engine.addFile('https://picsum.photos/200')
-  .start()
-  .then(results => console.log(results))
-  .catch(err => console.error(err));
+engine.addFile(bufferDeImagem);
+await engine.start();
+engine.clean();
 ```
 
-## Eventos
-
-| Evento | Descrição |
-|--------|-----------|
-| `st.start` | Disparado ao iniciar o processamento de um arquivo |
-| `st.info` | Metadados do arquivo sendo processado |
-| `st.data` | Sticker gerado com sucesso |
-| `st.error` | Erro ao processar um arquivo |
-
-## API
-
-### `new StickEngine(options)`
-
-| Opção | Tipo | Descrição |
-|-------|------|-----------|
-| `metadata.pack` | `string` | Nome do pacote de stickers |
-| `metadata.author` | `string` | Nome do autor |
-| `metadata.emojis` | `string[]` | Emojis associados ao sticker |
-| `transparent` | `string[]` | Chaves da API remove.bg para remoção de fundo |
-
-### `.addFile(input)`
-
-Adiciona um arquivo à fila. Aceita URL, Buffer ou caminho local. Retorna a instância para encadeamento.
+### 4. Remoção de Fundo (Remove.bg)
+```javascript
+const engine = new StickEngine({
+  transparent: 'SUA_API_KEY_AQUI'
+});
 
-### `.start()`
+engine.addFile('foto_com_fundo.png');
+await engine.start();
+engine.clean();
+```
 
-Inicia o processamento da fila. Retorna uma Promise com os resultados.
+---
 
-### `getBuffer(url)`
+## ⚙️ Opções do Construtor
 
-Utilitário para baixar uma URL como Buffer.
+| Opção | Tipo | Padrão | Descrição |
+| :--- | :--- | :--- | :--- |
+| `metadata` | `Object` | `{ pack: 'StickEngine', author: 'Borutovk7' }` | Nome do pacote e autor. |
+| `edit` | `Object` | `false` | Filtros (`sepia`, `greyscale`, `invert`, `blur`) e `text`. |
+| `transparent` | `String` | `false` | Chave da API `remove.bg` para remover fundo. |
+| `autoClean` | `Boolean` | `true` | Habilita o rastreio de arquivos para limpeza. |
+| `quality` | `Number` | `80` | Qualidade do WebP (1-100). |
+| `fps` | `Number` | `15` | Frames por segundo para animações. |
 
-```javascript
-import { getBuffer } from '@boruto_vk7/stickengine';
+---
 
-const buffer = await getBuffer('https://example.com/image.png');
-```
+## 🤝 Contribuições
 
-## Créditos
+Contribuições são sempre bem-vindas! Sinta-se à vontade para abrir uma **Issue** ou enviar um **Pull Request**.
 
-- [Eduh dev](https://github.com/Borutovk7)
+Desenvolvido por [Borutovk7](https://github.com/Borutovk7) e [Eduh Dev](https://github.com/EduhDev).
 
+---
 
-## Licença
+## 📄 Licença
 
-ISC
+Este projeto está sob a licença [ISC](LICENSE).

package/dist/StickEngine.d.ts

@@ -5,25 +5,46 @@ export interface StickerMetadata {
     author?: string;
     emojis?: string[];
 }
+export interface JimpOptions {
+    greyscale?: boolean;
+    invert?: boolean;
+    sepia?: boolean;
+    blur?: number;
+    resize?: {
+        width: number;
+        height: number;
+    };
+    text?: {
+        content: string;
+        alignmentX?: number;
+        alignmentY?: number;
+        color?: string;
+    };
+}
 export interface StickEngineOptions {
     webp?: boolean;
-    edit?: string | boolean;
+    edit?: JimpOptions | boolean;
     convert?: boolean;
     transparent?: string | string[] | false;
     metadata?: StickerMetadata;
+    autoClean?: boolean;
+    fps?: number;
+    quality?: number;
 }
 /**
  * Faz GET em uma URL e retorna o corpo como Buffer.
- * Fornecido pelo usuário para integração.
  */
 export declare const getBuffer: (url: string, options?: AxiosRequestConfig) => Promise<Buffer>;
 export declare class StickEngine extends EventEmitter {
     options: StickEngineOptions;
     private tempDir;
     private queue;
+    private createdFiles;
     constructor(options?: StickEngineOptions);
     addFile(file: string | Buffer): this;
+    clean(): void;
     private processFile;
+    private applyJimpEdits;
     private getMediaInfo;
     private convertToWebp;
     private addExif;

package/dist/StickEngine.js

@@ -3,18 +3,14 @@ import path from 'path';
 import axios from 'axios';
 import { exec } from 'child_process';
 import { EventEmitter } from 'events';
-import ffmpeg from 'fluent-ffmpeg';
-// @ts-ignore
 import webpMux from 'node-webpmux';
-// @ts-ignore
+import Jimp from 'jimp';
 import { removeBackgroundFromImageFile } from 'remove.bg';
 import { fileURLToPath } from 'url';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-/**
- * Faz GET em uma URL e retorna o corpo como Buffer.
- * Fornecido pelo usuário para integração.
- */
+
 export const getBuffer = async (url, options = {}) => {
     try {
         const { data } = await axios({
@@ -32,17 +28,20 @@ export const getBuffer = async (url, options = {}) => {
     }
     catch (err) {
         console.error(`Erro em getBuffer: ${err}`);
-        const errorImagePath = path.join(__dirname, 'src', 'emror.jpg');
+        const errorImagePath = path.join(__dirname, 'emror.jpg');
         if (fs.existsSync(errorImagePath)) {
             return fs.readFileSync(errorImagePath);
         }
         return Buffer.alloc(0);
     }
 };
+
 export class StickEngine extends EventEmitter {
     options;
     tempDir;
     queue;
+    createdFiles;
+
     constructor(options = {}) {
         super();
         this.options = {
@@ -50,6 +49,9 @@ export class StickEngine extends EventEmitter {
             edit: false,
             convert: false,
             transparent: false,
+            autoClean: true,
+            fps: 15,
+            quality: 80,
             metadata: {
                 pack: 'StickEngine',
                 author: 'Borutovk7 & Eduh Dev',
@@ -62,24 +64,44 @@ export class StickEngine extends EventEmitter {
             fs.mkdirSync(this.tempDir, { recursive: true });
         }
         this.queue = [];
+        this.createdFiles = [];
     }
+
     addFile(file) {
         this.queue.push(file);
         return this;
     }
+
+    clean() {
+        for (const file of this.createdFiles) {
+            try {
+                if (fs.existsSync(file)) {
+                    fs.unlinkSync(file);
+                }
+            }
+            catch (err) {
+                console.error(`Erro ao deletar arquivo temporário ${file}:`, err);
+            }
+        }
+        this.createdFiles = [];
+    }
+
     async processFile(input, index) {
-        let filePath;
-        let extension;
+        let filePath = '';
+        let extension = '';
         const timestamp = Date.now();
+        const localCreatedFiles = [];
         try {
             this.emit('st.start', { index, input });
             const ft = await import('file-type');
             const fileTypeFunc = ft.fromBuffer || ft.fileTypeFromBuffer || (ft.default && (ft.default.fromBuffer || ft.default.fileTypeFromBuffer));
+
             if (Buffer.isBuffer(input)) {
                 const type = await fileTypeFunc(input);
                 extension = type ? type.ext : 'bin';
                 filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
                 fs.writeFileSync(filePath, input);
+                localCreatedFiles.push(filePath);
             }
             else if (typeof input === 'string' && input.startsWith('http')) {
                 const buffer = await getBuffer(input);
@@ -87,18 +109,28 @@ export class StickEngine extends EventEmitter {
                 extension = type ? type.ext : 'bin';
                 filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
                 fs.writeFileSync(filePath, buffer);
+                localCreatedFiles.push(filePath);
             }
             else if (typeof input === 'string' && fs.existsSync(input)) {
-                extension = path.extname(input).slice(1);
                 filePath = input;
             }
             else {
                 throw new Error('Tipo de entrada inválido ou arquivo não encontrado.');
             }
-            const metadata = await this.getMediaInfo(filePath);
-            this.emit('st.info', { index, ...metadata });
+
+            const mediaInfo = await this.getMediaInfo(filePath);
+            this.emit('st.info', { index, ...mediaInfo });
             let currentFile = filePath;
-            if (this.options.transparent) {
+            const isAnimated = mediaInfo.duration > 0 || extension === 'gif' || extension === 'mp4' || extension === 'webp';
+
+            if (this.options.edit && !isAnimated) {
+                const editedPath = path.join(this.tempDir, `edited_${timestamp}_${index}.png`);
+                await this.applyJimpEdits(currentFile, editedPath, this.options.edit);
+                localCreatedFiles.push(editedPath);
+                currentFile = editedPath;
+            }
+
+            if (this.options.transparent && !isAnimated) {
                 const apiKey = Array.isArray(this.options.transparent)
                     ? this.options.transparent[Math.floor(Math.random() * this.options.transparent.length)]
                     : this.options.transparent;
@@ -111,78 +143,117 @@ export class StickEngine extends EventEmitter {
                         type: 'auto'
                     });
                     fs.writeFileSync(bgRemovedPath, Buffer.from(result.base64img, 'base64'));
+                    localCreatedFiles.push(bgRemovedPath);
                     currentFile = bgRemovedPath;
                 }
             }
+
             const webpPath = path.join(this.tempDir, `sticker_${timestamp}_${index}.webp`);
-            await this.convertToWebp(currentFile, webpPath);
+            await this.convertToWebp(currentFile, webpPath, isAnimated);
+            localCreatedFiles.push(webpPath);
             currentFile = webpPath;
+
             if (this.options.metadata) {
                 await this.addExif(currentFile, this.options.metadata);
             }
+
+            this.createdFiles.push(...localCreatedFiles);
             this.emit('st.data', { index, file: currentFile });
             return currentFile;
         }
         catch (error) {
             this.emit('st.error', { index, error: error.message });
+            for (const f of localCreatedFiles) {
+                if (fs.existsSync(f))
+                    fs.unlinkSync(f);
+            }
             throw error;
         }
     }
+
+    async applyJimpEdits(input, output, options) {
+        const image = await Jimp.read(input);
+        if (options.greyscale) image.greyscale();
+        if (options.invert)    image.invert();
+        if (options.sepia)     image.sepia();
+        if (options.blur)      image.blur(options.blur);
+        if (options.resize)    image.resize(options.resize.width, options.resize.height);
+        if (options.text) {
+            const font = await Jimp.loadFont(Jimp.FONT_SANS_32_WHITE);
+            image.print(font, 0, 0, {
+                text: options.text.content,
+                alignmentX: options.text.alignmentX || Jimp.HORIZONTAL_ALIGN_CENTER,
+                alignmentY: options.text.alignmentY || Jimp.VERTICAL_ALIGN_BOTTOM
+            }, image.bitmap.width, image.bitmap.height);
+        }
+        await image.writeAsync(output);
+    }
+
     getMediaInfo(file) {
-        return new Promise((resolve, reject) => {
-            exec(`ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0:s=x ${file}`, (err, stdout) => {
-                if (err)
-                    return reject(err);
-                const [width, height, duration] = stdout.split('x');
+        return new Promise((resolve) => {
+            exec(`ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0:s=x "${file}"`, (err, stdout) => {
+                if (err) return resolve({ width: 0, height: 0, duration: 0 });
+                const parts = stdout.trim().split('x');
                 resolve({
-                    width: parseInt(width) || 0,
-                    height: parseInt(height) || 0,
-                    duration: parseFloat(duration) || 0
+                    width: parseInt(parts[0]) || 0,
+                    height: parseInt(parts[1]) || 0,
+                    duration: parseFloat(parts[2]) || 0
                 });
             });
         });
     }
-    convertToWebp(input, output) {
+
+    convertToWebp(input, output, isAnimated) {
         return new Promise((resolve, reject) => {
-            ffmpeg(input)
-                .on('error', reject)
-                .on('end', () => resolve())
-                .addOutputOptions([
-                '-vcodec', 'libwebp',
-                '-vf', 'scale=512:512:force_original_aspect_ratio=decrease,fps=15,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1',
-                '-lossless', '1',
-                '-loop', '0',
-                '-preset', 'default',
-                '-an',
-                '-vsync', '0'
-            ])
-                .toFormat('webp')
-                .save(output);
+            const fps     = this.options.fps;
+            const quality = this.options.quality;
+            const scale   = `scale=512:512:force_original_aspect_ratio=decrease,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1`;
+
+            let cmd;
+            if (isAnimated) {
+                cmd = `ffmpeg -y -i "${input}" -vcodec libwebp -vf "fps=${fps},${scale}" -lossless 0 -q:v ${quality} -loop 0 -preset default -an -vsync 0 -t 6 "${output}"`;
+            } else {
+                cmd = `ffmpeg -y -i "${input}" -vcodec libwebp -vf "${scale}" -lossless 1 -loop 0 -preset default -an -vsync 0 "${output}"`;
+            }
+
+            exec(cmd, (err, stdout, stderr) => {
+                if (err) return reject(new Error(stderr || err.message));
+                resolve();
+            });
         });
     }
+
     async addExif(webpPath, metadata) {
-        const json = {
-            'sticker-pack-id': 'StickEngine-Manus',
-            'sticker-pack-name': metadata.pack || 'StickEngine',
-            'sticker-pack-publisher': metadata.author || 'Borutovk7 & Eduh Dev',
-            'emojis': metadata.emojis || ['🥶']
-        };
-        const Image = webpMux.Image || (webpMux.default && webpMux.default.Image);
-        const img = new Image();
-        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
-        const jsonBuff = Buffer.from(JSON.stringify(json), 'utf-8');
-        const exifBuffer = Buffer.concat([exifAttr, jsonBuff]);
-        exifBuffer.writeUIntLE(jsonBuff.length, 14, 4);
-        await img.load(webpPath);
-        img.exif = exifBuffer;
-        await img.save(webpPath);
+    const json = {
+        'sticker-pack-id': 'StickEngine-Official',
+        'sticker-pack-name': metadata.pack || 'StickEngine',
+        'sticker-pack-publisher': metadata.author || 'Borutovk7',
+        'emojis': metadata.emojis || ['🥶']
+    };
+
+    const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+    const jsonBuff = Buffer.from(JSON.stringify(json), 'utf-8');
+    const exifBuffer = Buffer.concat([exifAttr, jsonBuff]);
+    exifBuffer.writeUIntLE(jsonBuff.length, 14, 4);
+
+    const { Image } = webpMux;
+    const img = new Image();
+    await img.load(webpPath);
+    img.exif = exifBuffer;
+
+    if (img.hasAnim) {
+        await img.muxAnim({ path: webpPath });
+    } else {
+        await Image.save(webpPath, img);
     }
+}
+
     async start() {
-        if (this.queue.length === 0)
-            throw new Error('Nenhum arquivo na fila.');
+        if (this.queue.length === 0) throw new Error('Nenhum arquivo na fila.');
         const results = await Promise.allSettled(this.queue.map((file, i) => this.processFile(file, i)));
         this.queue = [];
         return results;
     }
 }
-export default StickEngine;
+
+export default StickEngine;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boruto_vk7/stickengine",
-  "version": "0.0.3-alpha",
+  "version": "0.0.5",
   "description": "StickEngine module for creating WhatsApp stickers",
   "type": "module",
   "main": "dist/StickEngine.js",