image-video-optimizer 3.0.3 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-video-optimizer",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "CLI tool to optimize and compress images and videos with configurable settings",
   "main": "src/index.js",
   "bin": {

package/src/videoProcessor.js

@@ -1,141 +1,113 @@
-const ffmpeg = require('fluent-ffmpeg');
 const fs = require('fs');
+const sharp = require('sharp');
 const path = require('path');
 
 /**
- * Process a single video file
- * @param {string} videoPath - Path to the video
+ * Process a single image file
+ * @param {string} imagePath - Path to the image
  * @param {object} config - Configuration object
  * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string}>}
  */
-async function processVideo(videoPath, config) {
-  return new Promise((resolve) => {
-    try {
-      fs.stat(videoPath, async (err, stat) => {
-        if (err) {
-          return resolve({
-            success: false,
-            originalSize: 0,
-            optimizedSize: 0,
-            message: `✗ ${path.basename(videoPath)} - Cannot access file`,
-            error: true
-          });
-        }
+async function processImage(imagePath, config) {
+  try {
+    const stat = await fs.promises.stat(imagePath);
+    const originalSize = stat.size;
+    const tmpPath = imagePath + '.tmp';
+    const ext = path.extname(imagePath).toLowerCase();
+    const directory = path.dirname(imagePath);
+    const filename = path.basename(imagePath, ext);
 
-        const originalSize = stat.size;
-        const tmpPath = videoPath + '.tmp.mp4';
-        const ext = path.extname(videoPath).toLowerCase();
-        const directory = path.dirname(videoPath);
-        const filename = path.basename(videoPath, ext);
-        const finalPath = path.join(directory, filename + '.mp4');
+    // Determine output format
+    const outputFormat = config.img_format.toLowerCase();
+    const outputExt = outputFormat === 'jpg' ? '.jpg' : `.${outputFormat}`;
+    const finalPath = path.join(directory, filename + outputExt);
 
-        // Create ffmpeg command
-        // Map codec names to ffmpeg codec names
-        const codecMap = {
-          'h264': 'libx264',
-          'h265': 'libx265',
-          'vp8': 'libvpx',
-          'vp9': 'libvpx-vp9'
-        };
-        
-        const outputCodec = codecMap[config.video_encode.toLowerCase()] || config.video_encode || 'libx264';
-        
-        const command = ffmpeg(videoPath)
-          .videoCodec(outputCodec)
-          .size(`${config.video_max_width}x?`)
-          .outputOptions([
-            '-preset fast',
-            '-crf 28'
-          ])
-          .output(tmpPath);
+    // Check if format conversion is needed
+    const needsFormatConversion = ext !== outputExt && ext !== (outputFormat === 'jpg' ? '.jpeg' : outputExt);
 
-        command
-          .on('end', async () => {
-            try {
-              const tmpStat = await new Promise((res, rej) => {
-                fs.stat(tmpPath, (err, stat) => {
-                  if (err) rej(err);
-                  else res(stat);
-                });
-              });
+    // Read and process image
+    let image = sharp(imagePath);
 
-              const optimizedSize = tmpStat.size;
+    // Get image metadata
+    const metadata = await image.metadata();
 
-              if (optimizedSize < originalSize) {
-                // Remove original and rename temp to final
-                await fs.promises.unlink(videoPath);
-                await fs.promises.rename(tmpPath, finalPath);
+    // Resize if width exceeds max_width
+    let wasResized = false;
+    if (metadata.width > config.img_max_width) {
+      image = image.resize(config.img_max_width, null, {
+        withoutEnlargement: true
+      });
+      wasResized = true;
+    }
+
+    // Convert to target format with optimization
+    if (outputFormat === 'jpg' || outputFormat === 'jpeg') {
+      image = image.jpeg({ quality: 80, progressive: true });
+    } else if (outputFormat === 'png') {
+      image = image.png({ compressionLevel: 9 });
+    } else if (outputFormat === 'webp') {
+      image = image.webp({ quality: 80 });
+    } else if (outputFormat === 'gif') {
+      image = image.gif();
+    } else if (outputFormat === 'tiff') {
+      image = image.tiff();
+    } else {
+      // Default to jpeg for unknown formats
+      image = image.jpeg({ quality: 80, progressive: true });
+    }
 
-                resolve({
-                  success: true,
-                  originalSize,
-                  optimizedSize,
-                  message: `✓ ${path.basename(videoPath)} → ${path.basename(finalPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
-                  filePath: finalPath
-                });
-              } else {
-                // Remove temp file if not smaller
-                await fs.promises.unlink(tmpPath);
+    // Write to temporary file
+    await image.toFile(tmpPath);
 
-                resolve({
-                  success: false,
-                  originalSize,
-                  optimizedSize,
-                  message: `○ ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
-                  filePath: videoPath
-                });
-              }
-            } catch (error) {
-              resolve({
-                success: false,
-                originalSize,
-                optimizedSize: 0,
-                message: `✗ ${path.basename(videoPath)} - Post-processing error: ${error.message}`,
-                error: true
-              });
-            }
-          })
-          .on('error', (err) => {
-            // Clean up temp file on error
-            fs.unlink(tmpPath, () => {
-              let errorMsg = err.message;
-              
-              // Provide helpful suggestions for common errors
-              if (err.message.includes('Unknown encoder') || err.message.includes('Encoder (')) {
-                errorMsg = `Codec "${outputCodec}" not supported. Try: video_encode=h264`;
-              } else if (err.message.includes('No such file') || err.message.includes('does not exist')) {
-                errorMsg = `Input file not found or cannot be read`;
-              } else if (err.message.includes('ENOENT') || err.message.includes('ffmpeg')) {
-                errorMsg = `FFmpeg not found. Install with: brew install ffmpeg`;
-              } else if (err.message.includes('Conversion failed') || err.message.includes('exited with code')) {
-                errorMsg = `Video encoding failed. Check file format and try different codec`;
-              } else {
-                errorMsg = `Encoding error: ${err.message.substring(0, 80)}`;
-              }
-              
-              resolve({
-                success: false,
-                originalSize,
-                optimizedSize: 0,
-                message: `✗ ${path.basename(videoPath)} - ${errorMsg}`,
-                error: true
-              });
-            });
-          })
-          .run();
-      });
-    } catch (error) {
-      resolve({
+    // Check if optimized file is smaller
+    const tmpStat = await fs.promises.stat(tmpPath);
+    const optimizedSize = tmpStat.size;
+
+    // Decide whether to replace: if smaller OR if format conversion needed OR if resized
+    const shouldReplace = optimizedSize < originalSize || needsFormatConversion || wasResized;
+
+    if (shouldReplace) {
+      // Remove original and rename temp to final path
+      if (finalPath !== imagePath) {
+        await fs.promises.unlink(imagePath);
+      }
+      await fs.promises.rename(tmpPath, finalPath);
+
+      const action = needsFormatConversion ? `${path.basename(imagePath)} → ${path.basename(finalPath)}` : path.basename(finalPath);
+      const sizeInfo = optimizedSize < originalSize 
+        ? `(${(originalSize / 1024).toFixed(1)}KB → ${(optimizedSize / 1024).toFixed(1)}KB)`
+        : `(${(originalSize / 1024).toFixed(1)}KB)`;
+
+      return {
+        success: true,
+        originalSize,
+        optimizedSize,
+        message: `✓ ${action} ${sizeInfo}`,
+        filePath: finalPath
+      };
+    } else {
+      // Remove temp file if not replacing
+      await fs.promises.unlink(tmpPath);
+
+      return {
         success: false,
-        originalSize: 0,
-        optimizedSize: 0,
-        message: `✗ ${path.basename(videoPath)} - Error: ${error.message}`,
-        error: true
-      });
+        originalSize,
+        optimizedSize,
+        message: `○ ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
+        filePath: imagePath
+      };
     }
-  });
+  } catch (error) {
+    return {
+      success: false,
+      originalSize: 0,
+      optimizedSize: 0,
+      message: `✗ ${path.basename(imagePath)} - Error: ${error.message}`,
+      error: true
+    };
+  }
 }
 
 module.exports = {
-  processVideo
+  processImage
 };