@boruto_vk7/stickengine 0.0.6 → 1.0.0

package/dist/StickEngine.js

@@ -1,369 +0,0 @@
-import fs from 'fs';
-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';
-// @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);
-/**
- * Faz GET em uma URL e retorna o corpo como Buffer.
- */
-export const getBuffer = async (url, options = {}) => {
-    try {
-        const { data } = await axios({
-            method: 'get',
-            url,
-            headers: {
-                'user-agent': 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.128 Safari/537.36',
-                'DNT': '1',
-                'Upgrade-Insecure-Request': '1',
-            },
-            ...options,
-            responseType: 'arraybuffer',
-        });
-        return Buffer.from(data);
-    }
-    catch (err) {
-        console.error(`Erro em getBuffer: ${err}`);
-        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 = {
-            webp: true,
-            edit: false,
-            convert: false,
-            transparent: false,
-            autoClean: true,
-            fps: 15,
-            quality: 80,
-            metadata: {
-                pack: 'StickEngine',
-                author: 'Borutovk7 & Eduh Dev',
-                emojis: ['🥶']
-            },
-            ...options
-        };
-        this.tempDir = path.join(process.cwd(), 'tmp_stickengine');
-        if (!fs.existsSync(this.tempDir)) {
-            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 = '';
-        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);
-                const type = await fileTypeFunc(buffer);
-                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)) {
-                filePath = input;
-            }
-            else {
-                throw new Error('Tipo de entrada inválido ou arquivo não encontrado.');
-            }
-            const mediaInfo = await this.getMediaInfo(filePath);
-            this.emit('st.info', { index, ...mediaInfo });
-            let currentFile = filePath;
-            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;
-                if (typeof apiKey === 'string') {
-                    const bgRemovedPath = path.join(this.tempDir, `nobg_${timestamp}_${index}.png`);
-                    const result = await removeBackgroundFromImageFile({
-                        path: currentFile,
-                        apiKey,
-                        size: 'auto',
-                        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, 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.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 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
-            };
-            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);
-    }
-    getMediaInfo(file) {
-        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(parts[0]) || 0,
-                    height: parseInt(parts[1]) || 0,
-                    duration: parseFloat(parts[2]) || 0
-                });
-            });
-        });
-    }
-    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++;
-            }
-        }
-    }
-    async addExif(webpPath, metadata) {
-        const json = {
-            'sticker-pack-id': 'StickEngine-Official',
-            'sticker-pack-name': metadata.pack || 'StickEngine',
-            'sticker-pack-publisher': metadata.author || 'Borutovk7',
-            '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;
-        // 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;