webp-light-converter 1.0.0

package/README.md

@@ -0,0 +1,141 @@
+# WebP Light Converter
+
+Uma biblioteca leve para converter imagens para formato WebP com compressão sem perdas.
+
+## 🚀 Instalação
+
+```bash
+npm install webp-light-converter
+```
+
+## 📋 Características
+
+- ✅ Conversão sem perdas (lossless)
+- ✅ Máxima qualidade preservada
+- ✅ Suporte a múltiplos formatos de entrada
+- ✅ Conversão em lote de diretórios
+- ✅ Preservação de metadados da imagem
+- ✅ API simples e direta
+- ⚡ Alta performance com Sharp
+
+## 📁 Formatos Suportados
+
+**Entrada:** JPG, JPEG, PNG, BMP, TIFF, GIF  
+**Saída:** WebP
+
+## 📚 Uso
+
+### Importando a biblioteca
+
+```javascript
+const { convertFile, convertPath } = require('webp-light-converter');
+```
+
+### Converter um arquivo único
+
+```javascript
+const { convertFile } = require('webp-light-converter');
+const fs = require('fs');
+
+async function exemplo() {
+  try {
+    // Converte uma imagem para buffer WebP
+    const webpBuffer = await convertFile('./input/image.jpg');
+    
+    // Salva o buffer em um arquivo
+    fs.writeFileSync('./output/image.webp', webpBuffer);
+    
+    console.log('Conversão concluída!');
+  } catch (error) {
+    console.error('Erro na conversão:', error.message);
+  }
+}
+
+exemplo();
+```
+
+### Converter um diretório inteiro
+
+```javascript
+const { convertPath } = require('webp-light-converter');
+
+async function exemploLote() {
+  try {
+    const resultados = await convertPath('./input', './output');
+    
+    resultados.forEach(resultado => {
+      if (resultado.success) {
+        console.log(`✅ ${resultado.input} → ${resultado.output}`);
+      } else {
+        console.log(`❌ ${resultado.input}: ${resultado.error}`);
+      }
+    });
+  } catch (error) {
+    console.error('Erro na conversão:', error.message);
+  }
+}
+
+exemploLote();
+```
+
+## 🔧 API
+
+### `convertFile(inputPath)`
+
+Converte um único arquivo de imagem para formato WebP.
+
+- **inputPath** `{string}` - Caminho para o arquivo de entrada
+- **Retorna** `{Promise<Buffer>}` - Buffer contendo a imagem WebP
+- **Lança** `{Error}` - Se o arquivo não for encontrado
+
+### `convertPath(inputDir, outputDir)`
+
+Converte todas as imagens de um diretório para formato WebP.
+
+- **inputDir** `{string}` - Diretório de entrada
+- **outputDir** `{string}` - Diretório de saída
+- **Retorna** `{Promise<Array>}` - Array com resultados da conversão
+- **Lança** `{Error}` - Se o diretório de entrada não existir
+
+#### Formato do resultado:
+
+```javascript
+[
+  {
+    success: true,
+    input: 'image.jpg',
+    output: 'image.webp',
+    path: '/path/to/output/image.webp'
+  },
+  {
+    success: false,
+    input: 'corrupted.png',
+    error: 'Mensagem de erro'
+  }
+]
+```
+
+## ⚙️ Configurações
+
+A biblioteca usa configurações otimizadas para máxima qualidade:
+
+- **Lossless**: `true` (sem perdas)
+- **Quality**: `100` (máxima qualidade)
+- **Effort**: `6` (máximo esforço de compressão)
+- **Metadados**: Preservados
+
+## 📄 Licença
+
+MIT © [Jonatan966](https://ojonatan.dev)
+
+## 🤝 Contribuindo
+
+1. Faça um fork do projeto
+2. Crie sua feature branch (`git checkout -b feature/nova-funcionalidade`)
+3. Commit suas mudanças (`git commit -am 'Adiciona nova funcionalidade'`)
+4. Push para a branch (`git push origin feature/nova-funcionalidade`)
+5. Abra um Pull Request
+
+## 🐛 Reportar Problemas
+
+[Abra uma issue](https://github.com/Jonatan966/webp-light-converter/issues) no GitHub.

package/index.js

@@ -0,0 +1,134 @@
+const sharp = require("sharp");
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Converte um único arquivo de imagem para formato WebP com compressão sem perdas.
+ * 
+ * @param {string} inputPath - Caminho absoluto ou relativo para o arquivo de imagem de entrada
+ * @returns {Promise<Buffer>} Buffer contendo a imagem convertida em formato WebP
+ * @throws {Error} Lança erro se o arquivo de entrada não for encontrado
+ * 
+ * @example
+ * // Converter uma imagem JPG para WebP
+ * const webpBuffer = await convertFile('./images/photo.jpg');
+ * fs.writeFileSync('./output/photo.webp', webpBuffer);
+ * 
+ * @example
+ * // Tratamento de erro
+ * try {
+ *   const buffer = await convertFile('./nonexistent.png');
+ * } catch (error) {
+ *   console.error('Arquivo não encontrado:', error.message);
+ * }
+ */
+async function convertFile(inputPath) {
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Arquivo de origem não encontrado: ${inputPath}`);
+  }
+
+  return await sharp(inputPath)
+    .webp({
+      lossless: true,
+      quality: 100,
+      effort: 6,
+    })
+    .keepMetadata()
+    .toBuffer();
+}
+
+/**
+ * Converte todas as imagens suportadas de um diretório para formato WebP.
+ * Cria o diretório de saída automaticamente se não existir.
+ * 
+ * @param {string} inputDir - Caminho para o diretório contendo as imagens de entrada
+ * @param {string} outputDir - Caminho para o diretório onde as imagens WebP serão salvas
+ * @returns {Promise<Array<Object>>} Array com resultados da conversão de cada imagem
+ * @throws {Error} Lança erro se o diretório de entrada não existir
+ * 
+ * @example
+ * // Converter todas as imagens de uma pasta
+ * const results = await convertPath('./input', './output');
+ * console.log(`${results.filter(r => r.success).length} imagens convertidas`);
+ * 
+ * @example
+ * // Verificar resultados individuais
+ * const results = await convertPath('./photos', './webp-photos');
+ * results.forEach(result => {
+ *   if (result.success) {
+ *     console.log(`✅ ${result.input} → ${result.output}`);
+ *   } else {
+ *     console.log(`❌ Erro em ${result.input}: ${result.error}`);
+ *   }
+ * });
+ * 
+ * @description
+ * Formatos suportados: .jpg, .jpeg, .png, .bmp, .tiff, .gif
+ * 
+ * Estrutura do resultado:
+ * {
+ *   success: boolean,     // Se a conversão foi bem-sucedida
+ *   input: string,        // Nome do arquivo original
+ *   output?: string,      // Nome do arquivo WebP gerado (se success=true)
+ *   path?: string,        // Caminho completo do arquivo gerado (se success=true)
+ *   error?: string        // Mensagem de erro (se success=false)
+ * }
+ */
+async function convertPath(inputDir, outputDir) {
+  if (!fs.existsSync(inputDir)) {
+    throw new Error(`Pasta de origem não encontrada: ${inputDir}`);
+  }
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  const supportedExtensions = [
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".bmp",
+    ".tiff",
+    ".gif",
+  ];
+
+  const files = fs.readdirSync(inputDir);
+
+  const imageFiles = files.filter((file) => {
+    const ext = path.extname(file).toLowerCase();
+    return supportedExtensions.includes(ext);
+  });
+
+  const results = [];
+
+  for (const imageFile of imageFiles) {
+    try {
+      const inputPath = path.join(inputDir, imageFile);
+      const outputFileName = `${path.parse(imageFile).name}.webp`;
+      const outputPath = path.join(outputDir, outputFileName);
+
+      const webpBuffer = await convertFile(inputPath);
+      fs.writeFileSync(outputPath, webpBuffer);
+
+      results.push({
+        success: true,
+        input: imageFile,
+        output: outputFileName,
+        path: outputPath,
+      });
+    } catch (error) {
+      results.push({
+        success: false,
+        input: imageFile,
+        error: error.message,
+      });
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  convertFile,
+  convertPath,
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "webp-light-converter",
+  "version": "1.0.0",
+  "description": "A lightweight library for converting images to WebP format with lossless compression",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jonatan966/webp-light-converter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Jonatan966/webp-light-converter/issues"
+  },
+  "homepage": "https://github.com/Jonatan966/webp-light-converter#readme",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "webp",
+    "image",
+    "converter",
+    "conversion",
+    "lossless",
+    "compression",
+    "optimization",
+    "sharp",
+    "batch",
+    "jpg",
+    "jpeg",
+    "png",
+    "bmp",
+    "tiff",
+    "gif",
+    "lightweight",
+    "image-processing",
+    "performance",
+    "nodejs"
+  ],
+  "author": "Jonatan966",
+  "maintainers": [
+    {
+      "name": "Jonatan",
+      "email": "jonatanfrederico@gmail.com",
+      "url": "https://ojonatan.dev"
+    }
+  ],
+  "contributors": [
+    {
+      "name": "Jonatan",
+      "email": "jonatanfrederico@gmail.com",
+      "url": "https://ojonatan.dev"
+    }
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "sharp": "^0.34.5"
+  }
+}

package/test/test.js

@@ -0,0 +1,68 @@
+const { convertFile, convertPath } = require('../index.js');
+const fs = require('fs');
+const path = require('path');
+
+async function runTests() {
+  console.log('🧪 Iniciando testes da WebP Light Converter...\n');
+  
+  try {
+    // Teste 1: Conversão de arquivo único
+    console.log('📋 Teste 1: Conversão de arquivo único');
+    console.log('Convertendo test/example.png...');
+    
+    const webpBuffer = await convertFile('./test/example.png');
+    
+    // Criar pasta de output se não existir
+    if (!fs.existsSync('./output')) {
+      fs.mkdirSync('./output');
+    }
+    
+    fs.writeFileSync('./output/example.webp', webpBuffer);
+    
+    const stats = fs.statSync('./output/example.webp');
+    console.log(`✅ Arquivo convertido com sucesso!`);
+    console.log(`   Tamanho: ${(stats.size / 1024).toFixed(2)} KB`);
+    console.log(`   Localização: ./output/example.webp\n`);
+    
+    // Teste 2: Conversão de diretório
+    console.log('📋 Teste 2: Conversão de diretório');
+    console.log('Convertendo pasta test/ para output/batch/...');
+    
+    const results = await convertPath('./test', './output/batch');
+    
+    console.log('\n📊 Resultados da conversão em lote:');
+    results.forEach((result, index) => {
+      if (result.success) {
+        const stats = fs.statSync(result.path);
+        console.log(`   ${index + 1}. ✅ ${result.input} → ${result.output}`);
+        console.log(`      Tamanho: ${(stats.size / 1024).toFixed(2)} KB`);
+      } else {
+        console.log(`   ${index + 1}. ❌ ${result.input}: ${result.error}`);
+      }
+    });
+    
+    const successful = results.filter(r => r.success).length;
+    console.log(`\n🎉 Testes concluídos: ${successful}/${results.length} conversões bem-sucedidas`);
+    
+    // Teste 3: Tratamento de erro
+    console.log('\n📋 Teste 3: Tratamento de erro (arquivo inexistente)');
+    try {
+      await convertFile('./inexistente.jpg');
+      console.log('❌ Erro: deveria ter lançado exceção');
+    } catch (error) {
+      console.log(`✅ Erro capturado corretamente: ${error.message}`);
+    }
+    
+    console.log('\n🎯 Todos os testes foram executados com sucesso!');
+    console.log('\n📁 Arquivos gerados:');
+    console.log('   - ./output/example.webp');
+    console.log('   - ./output/batch/example.webp');
+    
+  } catch (error) {
+    console.error('❌ Erro durante os testes:', error.message);
+    process.exit(1);
+  }
+}
+
+// Executar testes
+runTests();