image-video-optimizer 3.4.0 → 3.5.1

package/.image-video-optimizer-status.json

@@ -0,0 +1,6 @@
+{
+  "processed": [],
+  "failed": [],
+  "startTime": null,
+  "lastRun": "2026-04-14T14:04:49.168Z"
+}

package/.image-video-optimizer.conf

@@ -1,8 +1,8 @@
 # Image Video Optimizer Configuration
 # Generated automatically
 
-img_max_width=1080          # Maximum width for images (pixels)
-img_format=jpg              # Target format for image conversion
+max_image_width=720         # Compress images wider than this (pixels)
+img_format=null              # Target format for image conversion (null=no conversion)
 video_max_width=720         # Maximum width for videos (pixels)
 video_encode=h264           # Video encoding format
 audio_ext=mp3                 # Audio extension for audio files

package/README.md

@@ -51,7 +51,7 @@ Create a `.image-video-optimizer.conf` file in your target directory to customiz
 
 ```ini
 # Image settings
-img_max_width=1080          # Maximum width for images (pixels)
+img_max_width=720          # Maximum width for images (pixels)
 img_format=jpg              # Target format for image conversion
 
 # Video settings
@@ -68,7 +68,7 @@ pdf_compress=true           # Enable/disable PDF compression
 ### Default Configuration
 
 If no configuration file is found, these defaults are used:
-- `img_max_width`: 1080
+- `img_max_width`: 720
 - `img_format`: jpg
 - `video_max_width`: 720
 - `video_encode`: h264
@@ -79,7 +79,7 @@ If no configuration file is found, these defaults are used:
 
 ### Images
 - Input: jpg, jpeg, png, gif, bmp, tiff, webp
-- Output: jpg, png, webp (configurable)
+- Output: jpg, png, webp (as it is but compressed with better algorithms like avif webp)
 
 ### Videos
 - Input: avi, mov, wmv, flv, webm, mkv, m4v, mp4
@@ -148,10 +148,10 @@ image-video-optimizer ./photos --verbose
 ### Custom configuration
 Create `.image-video-optimizer.conf`:
 ```ini
-img_max_width=1920
+img_max_width=720
 img_format=webp
-video_max_width=1080
-video_encode=h265
+video_max_width=720
+video_encode=h264
 audio_ext=mp3
 pdf_compress=true
 ```

package/package.json

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

package/src/imageProcessor.js

@@ -3,98 +3,165 @@ const sharp = require('sharp');
 const path = require('path');
 
 /**
- * Process a single image file
+ * Get compression options for a specific format
+ * @param {string} format - Output format (jpg, png, webp, avif)
+ * @returns {object} Sharp compression options
+ */
+function getCompressionOptions(format) {
+  const options = {
+    jpg: { quality: 80, progressive: true },
+    jpeg: { quality: 80, progressive: true },
+    png: { compressionLevel: 9 },
+    webp: { quality: 80 },
+    avif: { quality: 75 }
+  };
+  return options[format.toLowerCase()] || options.jpg;
+}
+
+/**
+ * Compress image to a specific format
+ * @param {object} image - Sharp image object
+ * @param {string} format - Target format
+ * @returns {object} Sharp pipeline with format applied
+ */
+function applyFormat(image, format) {
+  const formatLower = format.toLowerCase();
+  const options = getCompressionOptions(formatLower);
+
+  switch (formatLower) {
+    case 'jpg':
+    case 'jpeg':
+      return image.jpeg(options);
+    case 'png':
+      return image.png(options);
+    case 'webp':
+      return image.webp(options);
+    case 'avif':
+      return image.avif(options);
+    case 'gif':
+      return image.gif();
+    case 'tiff':
+      return image.tiff();
+    default:
+      return image.jpeg(options);
+  }
+}
+
+/**
+ * Process image with multiple formats and keep the smallest
  * @param {string} imagePath - Path to the image
  * @param {object} config - Configuration object
- * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string}>}
+ * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string, filePath: string}>}
  */
 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);
 
-    // Determine output format
-    const outputFormat = config.img_format.toLowerCase();
-    const outputExt = outputFormat === 'jpg' ? '.jpg' : `.${outputFormat}`;
-    const finalPath = path.join(directory, filename + outputExt);
-
-    // Check if format conversion is needed
-    const needsFormatConversion = ext !== outputExt && ext !== (outputFormat === 'jpg' ? '.jpeg' : outputExt);
+    // Get max_image_width from config (default to 720)
+    const maxImageWidth = config.max_image_width || 720;
 
-    // Read and process image
+    // Read and get metadata
     let image = sharp(imagePath);
-
-    // Get image metadata
     const metadata = await image.metadata();
 
-    // 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
+    // Step 1: Apply conditional crop/resize based on max_image_width
+    let wasCropped = false;
+    if (metadata.width > maxImageWidth) {
+      image = image.resize(maxImageWidth, null, {
+        withoutEnlargement: true,
+        fit: 'inside'
       });
-      wasResized = true;
+      wasCropped = 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 });
-    }
+    // Step 2: Compress original image format to temp file
+    const originalTmpPath = path.join(directory, `${filename}.original.tmp`);
+    const originalFormatImage = applyFormat(image.clone(), ext.replace('.', ''));
+    await originalFormatImage.toFile(originalTmpPath);
+    const originalTmpStat = await fs.promises.stat(originalTmpPath);
+    const originalCompressedSize = originalTmpStat.size;
+
+    // Step 3: Compress to AVIF and WebP formats to temp files
+    const avifTmpPath = path.join(directory, `${filename}.avif.tmp`);
+    const webpTmpPath = path.join(directory, `${filename}.webp.tmp`);
+
+    const avifImage = applyFormat(image.clone(), 'avif');
+    await avifImage.toFile(avifTmpPath);
+    const avifTmpStat = await fs.promises.stat(avifTmpPath);
+    const avifCompressedSize = avifTmpStat.size;
 
-    // Write to temporary file
-    await image.toFile(tmpPath);
+    const webpImage = applyFormat(image.clone(), 'webp');
+    await webpImage.toFile(webpTmpPath);
+    const webpTmpStat = await fs.promises.stat(webpTmpPath);
+    const webpCompressedSize = webpTmpStat.size;
 
-    // Check if optimized file is smaller
-    const tmpStat = await fs.promises.stat(tmpPath);
-    const optimizedSize = tmpStat.size;
+    // Step 4: Compare sizes and determine best format
+    const formatComparison = [
+      { format: 'original', size: originalCompressedSize, tmpPath: originalTmpPath },
+      { format: 'avif', size: avifCompressedSize, tmpPath: avifTmpPath },
+      { format: 'webp', size: webpCompressedSize, tmpPath: webpTmpPath }
+    ];
 
-    // Decide whether to replace: if smaller OR if format conversion needed OR if resized
-    const shouldReplace = optimizedSize < originalSize || needsFormatConversion || wasResized;
+    // Sort by size to find the smallest
+    formatComparison.sort((a, b) => a.size - b.size);
+    const bestFormat = formatComparison[0];
+
+    // Step 5: Calculate compression savings
+    const optimizedSize = bestFormat.size;
+    const savedSize = originalSize - optimizedSize;
+    const savedPercent = ((savedSize / originalSize) * 100).toFixed(1);
+
+    // Step 6: Decide whether to replace
+    const shouldReplace = optimizedSize < originalSize || wasCropped;
 
     if (shouldReplace) {
-      // Remove original and rename temp to final path
-      if (finalPath !== imagePath) {
-        await fs.promises.unlink(imagePath);
-      }
-      await fs.promises.rename(tmpPath, finalPath);
+      // Read the best file and save it with original filename + extension
+      const bestFileContent = await fs.promises.readFile(bestFormat.tmpPath);
+      const finalPath = imagePath; // Keep original filename and extension
+
+      await fs.promises.writeFile(finalPath, bestFileContent);
 
-      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)`;
+      // Clean up temp files
+      await Promise.all([
+        fs.promises.unlink(originalTmpPath).catch(() => {}),
+        fs.promises.unlink(avifTmpPath).catch(() => {}),
+        fs.promises.unlink(webpTmpPath).catch(() => {})
+      ]);
+
+      const compressionInfo = wasCropped ? `[CROPPED to ${maxImageWidth}px] ` : '';
+      const sizeInfo = `${(originalSize / 1024).toFixed(1)}KB → ${(optimizedSize / 1024).toFixed(1)}KB (${savedPercent}% saved)`;
+      const formatInfo = bestFormat.format !== 'original' ? ` [${bestFormat.format.toUpperCase()} codec]` : '';
 
       return {
         success: true,
         originalSize,
         optimizedSize,
-        message: `✓ ${action} ${sizeInfo}`,
-        filePath: finalPath
+        savedSize,
+        savedPercent: parseFloat(savedPercent),
+        message: `✓ ${path.basename(imagePath)} ${compressionInfo}${sizeInfo}${formatInfo}`,
+        filePath: finalPath,
+        usedFormat: bestFormat.format,
+        wasCropped
       };
     } else {
-      // Remove temp file if not replacing
-      await fs.promises.unlink(tmpPath);
+      // Clean up temp files
+      await Promise.all([
+        fs.promises.unlink(originalTmpPath).catch(() => {}),
+        fs.promises.unlink(avifTmpPath).catch(() => {}),
+        fs.promises.unlink(webpTmpPath).catch(() => {})
+      ]);
 
       return {
         success: false,
         originalSize,
-        optimizedSize,
+        optimizedSize: originalSize,
         message: `○ ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
-        filePath: imagePath
+        filePath: imagePath,
+        usedFormat: 'original'
       };
     }
   } catch (error) {

package/src/index.js

@@ -7,8 +7,7 @@ const audioProcessor = require('./audioProcessor');
 const pdfProcessor = require('./pdfProcessor');
 
 const DEFAULT_CONFIG = {
-  img_max_width: 1080,
-  img_format: 'jpg',
+  max_image_width: 720,
   video_max_width: 720,
   video_encode: 'h264',
   audio_ext: 'mp3',
@@ -70,8 +69,7 @@ function ensureConfigFile(targetDir) {
     const configContent = `# Image Video Optimizer Configuration
 # Generated automatically
 
-img_max_width=${DEFAULT_CONFIG.img_max_width}          # Maximum width for images (pixels)
-img_format=${DEFAULT_CONFIG.img_format}              # Target format for image conversion
+max_image_width=${DEFAULT_CONFIG.max_image_width}         # Compress images wider than this (pixels)
 video_max_width=${DEFAULT_CONFIG.video_max_width}         # Maximum width for videos (pixels)
 video_encode=${DEFAULT_CONFIG.video_encode}           # Video encoding format
 audio_ext=${DEFAULT_CONFIG.audio_ext}                 # Audio extension for audio files
@@ -200,8 +198,7 @@ async function optimize(targetPath, verbose = false) {
   const status = loadStatus(targetDir);
 
   console.log('Configuration:');
-  console.log(`  Image Max Width: ${config.img_max_width}px`);
-  console.log(`  Image Format: ${config.img_format}`);
+  console.log(`  Image Max Width: ${config.max_image_width}px`);
   console.log(`  Video Max Width: ${config.video_max_width}px`);
   console.log(`  Video Encode: ${config.video_encode}`);
   console.log(`  Audio Extension: ${config.audio_ext}`);

package/src/config.js

@@ -1,57 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const DEFAULT_CONFIG = {
-  img_max_width: 1080,
-  img_format: 'jpg',
-  video_max_width: 720,
-  video_encode: 'h264'
-};
-
-class Config {
-  constructor(targetDir) {
-    this.targetDir = targetDir;
-    this.configPath = path.join(targetDir, '.image-video-optimizer.conf');
-    this.config = { ...DEFAULT_CONFIG };
-    this.loadConfig();
-  }
-
-  loadConfig() {
-    try {
-      if (fs.existsSync(this.configPath)) {
-        const configContent = fs.readFileSync(this.configPath, 'utf8');
-        const lines = configContent.split('\n');
-        
-        lines.forEach(line => {
-          line = line.trim();
-          if (line && !line.startsWith('#')) {
-            const [key, value] = line.split('=').map(s => s.trim());
-            if (key && value) {
-              if (key.includes('width') || key.includes('max_width')) {
-                this.config[key] = parseInt(value, 10);
-              } else {
-                this.config[key] = value;
-              }
-            }
-          }
-        });
-        
-        console.log(`Loaded configuration from ${this.configPath}`);
-      } else {
-        console.log('Using default configuration');
-      }
-    } catch (error) {
-      console.warn('Error loading configuration file, using defaults:', error.message);
-    }
-  }
-
-  get(key) {
-    return this.config[key];
-  }
-
-  getAll() {
-    return { ...this.config };
-  }
-}
-
-module.exports = Config;