@boruto_vk7/stickengine 0.0.3-alpha → 0.0.4

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

@@ -7,13 +7,14 @@ import ffmpeg from 'fluent-ffmpeg';
 // @ts-ignore
 import webpMux from 'node-webpmux';
 // @ts-ignore
+import Jimp from 'jimp';
+// @ts-ignore
 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 {
@@ -32,7 +33,7 @@ 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);
         }
@@ -43,6 +44,7 @@ export class StickEngine extends EventEmitter {
     options;
     tempDir;
     queue;
+    createdFiles;
     constructor(options = {}) {
         super();
         this.options = {
@@ -50,6 +52,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,15 +67,30 @@ 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');
@@ -80,6 +100,7 @@ export class StickEngine extends EventEmitter {
                 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 +108,27 @@ 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';
+            // Aplicar Edições Jimp (Apenas para Imagens Estáticas por enquanto)
+            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;
+            }
+            // Remoção de fundo (Apenas para Imagens Estáticas)
+            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,60 +141,97 @@ export class StickEngine extends EventEmitter {
                         type: 'auto'
                     });
                     fs.writeFileSync(bgRemovedPath, Buffer.from(result.base64img, 'base64'));
+                    localCreatedFiles.push(bgRemovedPath);
                     currentFile = bgRemovedPath;
                 }
             }
+            // Conversão para WebP (Suporta Estático e Animado)
             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;
+            // Adição de Metadados (Exif)
             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) => {
+        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 reject(err);
-                const [width, height, duration] = stdout.split('x');
+                    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)
+            const ff = ffmpeg(input)
                 .on('error', reject)
-                .on('end', () => resolve())
-                .addOutputOptions([
+                .on('end', () => resolve());
+            const videoOptions = [
                 '-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',
+                '-vf', `scale=512:512:force_original_aspect_ratio=decrease,fps=${this.options.fps},pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1`,
                 '-lossless', '1',
                 '-loop', '0',
                 '-preset', 'default',
                 '-an',
                 '-vsync', '0'
-            ])
+            ];
+            if (isAnimated) {
+                // Opções específicas para animação para manter o peso baixo (limite do WhatsApp é 1MB)
+                videoOptions.push('-t', '6'); // Limita a 6 segundos
+                videoOptions.push('-q:v', String(this.options.quality));
+            }
+            ff.addOutputOptions(videoOptions)
                 .toFormat('webp')
                 .save(output);
         });
     }
     async addExif(webpPath, metadata) {
         const json = {
-            'sticker-pack-id': 'StickEngine-Manus',
+            'sticker-pack-id': 'StickEngine-Official',
             'sticker-pack-name': metadata.pack || 'StickEngine',
-            'sticker-pack-publisher': metadata.author || 'Borutovk7 & Eduh Dev',
+            'sticker-pack-publisher': metadata.author || 'Borutovk7',
             'emojis': metadata.emojis || ['🥶']
         };
         const Image = webpMux.Image || (webpMux.default && webpMux.default.Image);

package/package.json

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