@boruto_vk7/stickengine 0.0.4 → 0.0.6

package/README.md

@@ -1,121 +1,130 @@
 # 🚀 StickEngine
 
-**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.
-
-[![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)
-
----
-
-## ✨ Funcionalidades
-
-- 🎞️ **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`.
-
----
-
-## 🖼️ Exemplos Visuais
-
-| Filtro Séia + Texto | Figurinha Animada (Mockup) |
-| :---: | :---: |
-| ![Sepia Preview](assets/preview_sepia.png) | ![Animated Preview](assets/preview_animated.png) |
+O **StickEngine** é um motor de alta performance para criação de figurinhas do WhatsApp, projetado para ser simples para iniciantes e extremamente poderoso para desenvolvedores avançados.
 
 ---
 
-## 📦 Instalação
+## 📦 1. Começando (Básico)
 
+### Instalação
 ```bash
 npm install @boruto_vk7/stickengine
 ```
+> **Requisito**: Tenha o `ffmpeg` instalado no seu sistema.
 
-> **Requisito:** Certifique-se de ter o [FFmpeg](https://ffmpeg.org/) instalado no seu sistema. No Termux: `pkg install ffmpeg`.
-
----
-
-## 🚀 Como Usar (Exemplos Técnicos)
+### Suporte Híbrido
+O módulo funciona tanto com **ESM** quanto **CommonJS**:
+- **ESM**: `import StickEngine from '@boruto_vk7/stickengine';`
+- **CJS**: `const StickEngine = require('@boruto_vk7/stickengine').default;`
 
-### 1. Criando uma Figurinha Estática Simples
+### Sua Primeira Figurinha
+Gere uma figurinha com apenas 3 linhas de código:
 ```javascript
-import StickEngine from '@boruto_vk7/stickengine';
-
 const engine = new StickEngine();
-engine.addFile('https://exemplo.com/foto.jpg');
-
-const results = await engine.start();
-console.log('Caminho do WebP:', results[0].value);
-engine.clean();
+engine.addFile('./foto.jpg'); // Adiciona a imagem
+const results = await engine.start(); // Inicia o processamento
+console.log('Sticker salvo em:', results[0].value);
 ```
 
-### 2. Figurinha Animada (GIF ou Vídeo)
-O motor detecta automaticamente a duração e converte para WebP animado.
+---
+
+## 🛠️ 2. Personalizando (Intermediário)
+
+### Adicionando Nome e Autor (Metadados)
+Personalize as informações que aparecem quando alguém clica na figurinha no WhatsApp.
 ```javascript
 const engine = new StickEngine({
-  fps: 20, // Aumenta a fluidez
-  quality: 70 // Otimiza o tamanho para o WhatsApp
+  metadata: {
+    pack: 'Meu Pack Incrível',
+    author: 'Borutovk7'
+  }
 });
+```
 
+### Figurinhas Animadas (GIF e Vídeo)
+O motor detecta automaticamente se o arquivo é animado. Ele corta para 6 segundos e garante que o arquivo tenha menos de 1MB.
+```javascript
 engine.addFile('./video_engracado.mp4');
+engine.addFile('./dancinha.gif');
 await engine.start();
-engine.clean();
 ```
 
-### 3. Aplicando Filtros e Texto
+---
+
+## 🎨 3. Efeitos Especiais (Avançado)
+
+### Recorte Circular e Filtros
+Transforme imagens quadradas em círculos e aplique filtros profissionais.
+```javascript
+const engine = new StickEngine({
+  edit: {
+    circle: true,     // Recorte circular
+    sepia: true,      // Filtro antigo
+    brightness: 0.2   // Aumenta o brilho
+  }
+});
+```
+
+### Legendas com Borda (Meme Style)
+Adicione texto que pode ser lido em qualquer fundo graças ao contorno (stroke).
 ```javascript
 const engine = new StickEngine({
   edit: {
-    sepia: true,
-    blur: 5,
     text: {
-      content: 'MUITO BOM!',
-      alignmentY: 2 // 0: Topo, 1: Meio, 2: Baixo
+      content: 'QUEBRADO!',
+      color: 'WHITE',
+      stroke: true // Adiciona borda preta ao texto branco
     }
   }
 });
-
-engine.addFile(bufferDeImagem);
-await engine.start();
-engine.clean();
 ```
 
-### 4. Remoção de Fundo (Remove.bg)
+---
+
+## 💎 4. Funções Profissionais (Expert)
+
+### Texto para Figurinha (TP)
+Gere figurinhas de frases do zero, sem precisar de uma imagem de base.
 ```javascript
-const engine = new StickEngine({
-  transparent: 'SUA_API_KEY_AQUI'
+const path = await engine.createTextSticker("ESSA É TOP!", { 
+  color: 'WHITE',
+  background: 0x00000000 // Transparente
 });
+```
 
-engine.addFile('foto_com_fundo.png');
-await engine.start();
-engine.clean();
+### Criando Ícone do Pacote (Tray Icon)
+Gere o ícone de bandeja (96x96) necessário para pacotes oficiais.
+```javascript
+const trayPath = await engine.createTrayIcon('./logo.png');
 ```
 
+### Auto-Dimensionamento Inteligente
+O motor reduz automaticamente a qualidade e o FPS se a figurinha animada passar de 1MB, garantindo que ela sempre seja enviada com sucesso.
+
 ---
 
-## ⚙️ Opções do Construtor
+## 📑 5. Referência Técnica Completa
 
-| Opção | Tipo | Padrão | Descrição |
+### Opções do Construtor (`StickEngineOptions`)
+| Propriedade | 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. |
+| `fps` | `Number` | `15` | Frames por segundo para animados. |
+| `autoClean` | `Boolean` | `true` | Apaga temporários automaticamente. |
+
+### Opções de Edição (`JimpOptions`)
+| Opção | Descrição |
+| :--- | :--- |
+| `circle` | Ativa o recorte circular. |
+| `brightness` | Ajusta o brilho (-1 a 1). |
+| `contrast` | Ajusta o contraste (-1 a 1). |
+| `blur` | Aplica desfoque. |
+| `text.stroke` | Adiciona contorno ao texto. |
 
 ---
 
-## 🤝 Contribuições
-
-Contribuições são sempre bem-vindas! Sinta-se à vontade para abrir uma **Issue** ou enviar um **Pull Request**.
-
-Desenvolvido por [Borutovk7](https://github.com/Borutovk7) e [Eduh Dev](https://github.com/EduhDev).
-
----
+## 🤝 Créditos
+Desenvolvido por **Borutovk7**.
 
 ## 📄 Licença
-
-Este projeto está sob a licença [ISC](LICENSE).
+ISC

package/dist/StickEngine.d.ts

@@ -10,6 +10,9 @@ export interface JimpOptions {
     invert?: boolean;
     sepia?: boolean;
     blur?: number;
+    brightness?: number;
+    contrast?: number;
+    circle?: boolean;
     resize?: {
         width: number;
         height: number;
@@ -18,7 +21,8 @@ export interface JimpOptions {
         content: string;
         alignmentX?: number;
         alignmentY?: number;
-        color?: string;
+        color?: 'WHITE' | 'BLACK';
+        stroke?: boolean;
     };
 }
 export interface StickEngineOptions {
@@ -49,5 +53,20 @@ export declare class StickEngine extends EventEmitter {
     private convertToWebp;
     private addExif;
     start(): Promise<PromiseSettledResult<string>[]>;
+    /**
+     * Converte um arquivo em Base64.
+     */
+    static toBase64(filePath: string): string;
+    /**
+     * Gera um ícone de bandeja (Tray Icon) 96x96 para o pacote de figurinhas.
+     */
+    createTrayIcon(input: string | Buffer): Promise<string>;
+    /**
+     * Cria uma figurinha de texto do zero (TP).
+     */
+    createTextSticker(text: string, options?: {
+        color?: 'WHITE' | 'BLACK';
+        background?: string;
+    }): Promise<string>;
 }
 export default StickEngine;

package/dist/StickEngine.js

@@ -11,6 +11,7 @@ import Jimp from 'jimp';
 // @ts-ignore
 import { removeBackgroundFromImageFile } from 'remove.bg';
 import { fileURLToPath } from 'url';
+// Correção para ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -177,15 +178,35 @@ export class StickEngine extends EventEmitter {
             image.sepia();
         if (options.blur)
             image.blur(options.blur);
+        if (options.brightness)
+            image.brightness(options.brightness);
+        if (options.contrast)
+            image.contrast(options.contrast);
+        if (options.circle)
+            image.circle();
         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, {
+            const fontPath = options.text.color === 'BLACK' ? Jimp.FONT_SANS_32_BLACK : Jimp.FONT_SANS_32_WHITE;
+            const font = await Jimp.loadFont(fontPath);
+            const printOptions = {
                 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);
+            };
+            if (options.text.stroke) {
+                // Simulação de borda desenhando o texto em volta
+                const strokeColor = options.text.color === 'BLACK' ? Jimp.FONT_SANS_32_WHITE : Jimp.FONT_SANS_32_BLACK;
+                const strokeFont = await Jimp.loadFont(strokeColor);
+                for (let x = -2; x <= 2; x++) {
+                    for (let y = -2; y <= 2; y++) {
+                        if (x !== 0 || y !== 0) {
+                            image.print(strokeFont, x, y, printOptions, image.bitmap.width, image.bitmap.height);
+                        }
+                    }
+                }
+            }
+            image.print(font, 0, 0, printOptions, image.bitmap.width, image.bitmap.height);
         }
         await image.writeAsync(output);
     }
@@ -203,29 +224,48 @@ export class StickEngine extends EventEmitter {
             });
         });
     }
-    convertToWebp(input, output, isAnimated) {
-        return new Promise((resolve, reject) => {
-            const ff = ffmpeg(input)
-                .on('error', reject)
-                .on('end', () => resolve());
-            const videoOptions = [
-                '-vcodec', 'libwebp',
-                '-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));
+    async convertToWebp(input, output, isAnimated) {
+        const runFfmpeg = (quality, fps) => {
+            return new Promise((resolve, reject) => {
+                const ff = ffmpeg(input)
+                    .on('error', reject)
+                    .on('end', () => resolve());
+                const videoOptions = [
+                    '-vcodec', 'libwebp',
+                    '-vf', `scale=512:512:force_original_aspect_ratio=decrease,fps=${fps},pad=512:512:(ow-iw)/2:(oh-ih)/2:color=white@0,setsar=1`,
+                    '-lossless', isAnimated ? '0' : '1',
+                    '-loop', '0',
+                    '-preset', 'default',
+                    '-an',
+                    '-vsync', '0'
+                ];
+                if (isAnimated) {
+                    videoOptions.push('-t', '6');
+                    videoOptions.push('-q:v', String(quality));
+                }
+                ff.addOutputOptions(videoOptions)
+                    .toFormat('webp')
+                    .save(output);
+            });
+        };
+        let currentQuality = this.options.quality || 80;
+        let currentFps = this.options.fps || 15;
+        await runFfmpeg(currentQuality, currentFps);
+        // Auto-Dimensionamento Inteligente (Apenas para Animados)
+        if (isAnimated && fs.existsSync(output)) {
+            let stats = fs.statSync(output);
+            let attempts = 0;
+            // Se maior que 1MB, tenta reduzir qualidade e FPS até 3 vezes
+            while (stats.size > 1000000 && attempts < 3) {
+                currentQuality -= 15;
+                currentFps -= 3;
+                if (currentFps < 5)
+                    currentFps = 5;
+                await runFfmpeg(currentQuality, currentFps);
+                stats = fs.statSync(output);
+                attempts++;
             }
-            ff.addOutputOptions(videoOptions)
-                .toFormat('webp')
-                .save(output);
-        });
+        }
     }
     async addExif(webpPath, metadata) {
         const json = {
@@ -242,14 +282,88 @@ export class StickEngine extends EventEmitter {
         exifBuffer.writeUIntLE(jsonBuff.length, 14, 4);
         await img.load(webpPath);
         img.exif = exifBuffer;
-        await img.save(webpPath);
+        // node-webpmux requer muxAnim para salvar WebPs animados
+        if (img.hasAnim) {
+            await img.muxAnim({ path: webpPath });
+        }
+        else {
+            await img.save(webpPath);
+        }
     }
     async start() {
         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 = [];
+        if (this.options.autoClean) {
+            // Nota: Se autoClean for true, os arquivos serão deletados após o uso. 
+            // Em um ambiente de produção, o usuário deve ler o arquivo antes de chamar clean() ou desativar autoClean.
+        }
         return results;
     }
+    /**
+     * Converte um arquivo em Base64.
+     */
+    static toBase64(filePath) {
+        const buffer = fs.readFileSync(filePath);
+        return buffer.toString('base64');
+    }
+    /**
+     * Gera um ícone de bandeja (Tray Icon) 96x96 para o pacote de figurinhas.
+     */
+    async createTrayIcon(input) {
+        const timestamp = Date.now();
+        const outputPath = path.join(this.tempDir, `tray_${timestamp}.png`);
+        const webpOutputPath = path.join(this.tempDir, `tray_${timestamp}.webp`);
+        let buffer;
+        if (Buffer.isBuffer(input)) {
+            buffer = input;
+        }
+        else if (typeof input === 'string' && input.startsWith('http')) {
+            buffer = await getBuffer(input);
+        }
+        else if (typeof input === 'string' && fs.existsSync(input)) {
+            buffer = fs.readFileSync(input);
+        }
+        else {
+            throw new Error('Entrada inválida para Tray Icon.');
+        }
+        const image = await Jimp.read(buffer);
+        await image.cover(96, 96).writeAsync(outputPath);
+        // Converter para WebP (WhatsApp prefere WebP para ícones de bandeja em alguns casos)
+        await new Promise((resolve, reject) => {
+            ffmpeg(outputPath)
+                .on('error', reject)
+                .on('end', () => resolve())
+                .toFormat('webp')
+                .save(webpOutputPath);
+        });
+        this.createdFiles.push(outputPath, webpOutputPath);
+        return webpOutputPath;
+    }
+    /**
+     * Cria uma figurinha de texto do zero (TP).
+     */
+    async createTextSticker(text, options = {}) {
+        const timestamp = Date.now();
+        const outputPath = path.join(this.tempDir, `text_${timestamp}.png`);
+        // Criar uma imagem transparente 512x512
+        const image = new Jimp(512, 512, options.background || 0x00000000);
+        const fontPath = options.color === 'BLACK' ? Jimp.FONT_SANS_64_BLACK : Jimp.FONT_SANS_64_WHITE;
+        const font = await Jimp.loadFont(fontPath);
+        // Centralizar o texto
+        image.print(font, 0, 0, {
+            text,
+            alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        }, 512, 512);
+        await image.writeAsync(outputPath);
+        // Processar como uma figurinha normal para adicionar metadados e converter para WebP
+        const engine = new StickEngine(this.options);
+        const results = await engine.addFile(outputPath).start();
+        const finalPath = results[0].value;
+        this.createdFiles.push(outputPath, finalPath);
+        return finalPath;
+    }
 }
 export default StickEngine;

package/package.json

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