auto-image-converter 2.1.1 → 2.2.0

package/README.md

@@ -1,69 +1,195 @@
 # 🖼️ Auto Image Converter
 
-Automatically convert PNG, JPG, and JPEG images to WebP or AVIF format with real-time file watching.
+Automatically convert and resize images to modern formats (WebP, AVIF, PNG, JPEG, TIFF) with real-time file watching and flexible resize options.
 
-### 🔗 GitHub repository: https://github.com/StoneZol/auto-image-converter
+## 🔗 GitHub repository
+
+<https://github.com/StoneZol/auto-image-converter>
 
 ## 🚀 Features
 
-🔄 Convert images to .webp or .avif
+🔄 **Convert images** to WebP, AVIF, PNG, JPEG, or TIFF
+
+📐 **Resize images** by width, height, or to specific aspect ratios
+
+🔍 **Recursive folder support** - process entire directory trees
 
-🔍 Recursive folder support
+🗑️ **Optional removal** of original files after conversion
 
-🗑️ Optional removal of original files
+👀 **Watch mode** – automatically converts newly added images in real-time
 
-👀 Watch mode – automatically converts newly added images
+⚡ **Parallel processing** with configurable concurrency
 
-⚙️ Easy configuration via image-converter.config.mjs
+🎯 **One-time resize** – resize already converted images without re-conversion
+
+⚙️ **Easy configuration** via `image-converter.config.mjs`
 
 ## 📦 Installation
 
-`npm install auto-image-converter --save-dev`
+```bash
+npm install auto-image-converter --save-dev
+```
+
+Or use locally via `npm link`:
+
+```bash
+cd auto-image-converter
+npm link
+cd ../your-project
+npm link auto-image-converter
+```
 
 ## ⚙️ Configuration
 
 Create a `image-converter.config.mjs` file in the root of your project:
 
-```// Default configuration example
+```javascript
 export default {
-  dir: "public",            // Directory to scan for images
-  converted: "*.{png,jpg,jpeg}", // Glob pattern for source image files to convert
-  format: "webp",           // Output image format: 'webp' or 'avif'
-  quality: 80,              // Quality of output images (0–100)
-  recursive: true,          // Whether to search subdirectories recursively
-  removeOriginal: true,     // Delete original files after successful conversion
-  ignoreOnStart: false,     // If true, ignore existing files on watcher startup
+  // Main settings
+  dir: "./public",              // Directory to scan for images
+  removeOriginal: true,          // Delete original files after conversion
+  recursive: true,               // Recursive search in subdirectories
+  ignoreOnStart: true,           // Ignore existing files on watcher startup
+  concurrency: 4,                // Number of parallel workers
+
+  // Conversion settings
+  convertation: {
+    converted: "*.{png,jpg,jpeg,tiff}",  // Source file pattern
+    format: "webp",                       // Target format: webp, avif, png, jpg, tiff
+    quality: 80,                          // Quality (0-100)
+    outputDir: null,                      // null = same folder, or path for output
+  },
+
+  // Resize settings (optional)
+  needResize: true,              // Enable resize
+  resize: {
+    width: 1920,                 // Width (or null)
+    height: null,                 // Height (or null)
+    fit: "cover",                 // cover, contain, fill, inside, outside
+    position: "center",           // Cropping position
+    withoutEnlargement: true,     // Don't enlarge small images
+  },
 };
 ```
 
+### Resize Options
+
+- **By width only**: `width: 1920, height: null` - reduces to width, height scales proportionally
+- **By height only**: `width: null, height: 1080` - reduces to height, width scales proportionally
+- **To aspect ratio**: `width: 1920, height: 1080` - fits/crops to specific aspect ratio
+
+### Fit Modes
+
+- `cover` - fills entire size, cropping excess (default)
+- `contain` - fits fully, may add padding
+- `fill` - stretches without preserving aspect ratio
+- `inside` - reduces to fit, doesn't enlarge
+- `outside` - covers entire size, may enlarge
+
 ## 🛠️ Usage
 
-Add the following to your package.json:
+### Commands
+
+```bash
+# One-time conversion of all files
+npx auto-convert-images
+
+# Watch mode - processes new files as they're added
+npx auto-convert-images-watch
+
+# One-time resize of already converted files
+npx auto-convert-images-resize
+```
+
+### Package.json Scripts
+
+Add to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "convert": "auto-convert-images",
+    "watch": "auto-convert-images-watch",
+    "resize": "auto-convert-images-resize"
+  }
+}
+```
+
+Then run:
+
+- `npm run convert` - one-time conversion
+- `npm run watch` - watch mode
+- `npm run resize` - resize already converted files
+
+### With Next.js
+
+To run the watcher alongside the development server:
 
+```bash
+npm install concurrently --save-dev
 ```
-"scripts": {
-  "aciw": "auto-convert-images-watch"
+
+```json
+{
+  "scripts": {
+    "dev": "concurrently \"npm run watch\" \"next dev\""
+  }
 }
 ```
 
-To start the image watcher: `npm run aciw`
+## 📋 Use Cases
 
-Or run a one-time conversion: `npx auto-convert-images`
+### 1. Initial Conversion
 
-## With Next.js
+Convert all PNG/JPG files to WebP:
 
-To run the watcher alongside the development server, install concurrently:
+```bash
+npx auto-convert-images
+```
 
-`npm install concurrently --save-dev`
+### 2. Watch Mode
 
-Then update your dev script like so:
+Automatically convert new images as they're added:
 
+```bash
+npx auto-convert-images-watch
 ```
-"scripts": {
-  "dev": "concurrently \"npm run aciw\" \"next dev\""
-}
+
+### 3. Resize Already Converted Files
+
+If you converted files without resize, then decided you need resize:
+
+```bash
+npx auto-convert-images-resize
 ```
 
+- If `removeOriginal: false` → creates new files with size suffix: `image.webp` → `image-1920x1080.webp`
+- If `removeOriginal: true` → overwrites original files
+
+## 🏗️ Architecture
+
+The tool uses a modular architecture:
+
+- **Pipeline** - main processing engine with queue and workers
+- **ResizeImages** - resize operations wrapper
+- **ConvertImages** - format conversion wrapper
+- **FileManager** - file path resolution and saving
+
+All operations work with Sharp instances in a chainable pipeline pattern.
+
+## 🐛 Bug Reports
+
+Found a bug? Please report it in the [GitHub Issues](https://github.com/StoneZol/auto-image-converter/issues) section of the repository. Include:
+
+- Description of the issue
+- Steps to reproduce
+- Expected behavior
+- Actual behavior
+- Configuration file (if relevant)
+- Node.js version and OS
+
+This helps improve the tool for everyone!
+
 ## 📄 License
 
 This project is open source and available under the MIT License.

package/bin/index.js

@@ -1,28 +1,59 @@
 #!/usr/bin/env node
 import path from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-import { convertImages } from "../lib/converter.js";
+import { pathToFileURL } from "url";
+import fs from "fs";
+import { Pipeline } from "../lib/Pipeline.js";
 
-const CONFIG_PATH = path.resolve(process.cwd(), "image-converter.config.mjs");
+const CONFIG_PATH = path.resolve(
+    process.cwd(),
+    "image-converter.config.mjs"
+);
 
 try {
-  const configModule = await import(pathToFileURL(CONFIG_PATH).href);
-  const config = configModule.default;
+    // Проверяем существование конфига
+    if (!fs.existsSync(CONFIG_PATH)) {
+        console.error(
+            `❌ Config file not found: ${CONFIG_PATH}\n` +
+            `   Please create 'image-converter.config.mjs' in the current directory.`
+        );
+        process.exit(1);
+    }
 
-  const absDir = path.resolve(
-    process.cwd(),
-    config.source || config.dir || "."
-  );
+    const configModule = await import(
+        pathToFileURL(CONFIG_PATH).href
+    );
+    const config = configModule.default;
+
+    if (!config) {
+        console.error(
+            `❌ Config file is empty or doesn't export default config.\n` +
+            `   File: ${CONFIG_PATH}`
+        );
+        process.exit(1);
+    }
+
+    const pipeline = new Pipeline(config);
+    const stats = await pipeline.run();
 
-  await convertImages({
-    dir: absDir,
-    converted: config.converted ?? "*.{png,jpg,jpeg}",
-    targetFormat: config.targetFormat ?? "webp",
-    quality: config.quality ?? 80,
-    recursive: config.recursive ?? true,
-    removeOriginal: config.removeOriginal ?? false,
-  });
+    console.log(`\n✅ Processing complete:`);
+    console.log(`   Total: ${stats.total}`);
+    console.log(`   Converted: ${stats.converted}`);
+    console.log(`   Skipped: ${stats.skipped}`);
+    console.log(`   Failed: ${stats.failed}`);
 } catch (e) {
-  console.error("❌ Ошибка загрузки конфигурации:", e.message);
-  process.exit(1);
+    if (e.code === "ERR_MODULE_NOT_FOUND" && e.message.includes("image-converter.config.mjs")) {
+        console.error(
+            `❌ Config file not found: ${CONFIG_PATH}\n` +
+            `   Please create 'image-converter.config.mjs' in the current directory.`
+        );
+    } else {
+        console.error(
+            "❌ Error:",
+            e.message
+        );
+        if (e.stack) {
+            console.error(e.stack);
+        }
+    }
+    process.exit(1);
 }

package/bin/onetimeresizer.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import path from "path";
+import { pathToFileURL } from "url";
+import fs from "fs";
+import { Pipeline } from "../lib/Pipeline.js";
+
+const CONFIG_PATH = path.resolve(
+    process.cwd(),
+    "image-converter.config.mjs"
+);
+
+try {
+    // Проверяем существование конфига
+    if (!fs.existsSync(CONFIG_PATH)) {
+        console.error(
+            `❌ Config file not found: ${CONFIG_PATH}\n` +
+            `   Please create 'image-converter.config.mjs' in the current directory.`
+        );
+        process.exit(1);
+    }
+
+    const configModule = await import(
+        pathToFileURL(CONFIG_PATH).href
+    );
+    const originalConfig = configModule.default;
+
+    if (!originalConfig) {
+        console.error(
+            `❌ Config file is empty or doesn't export default config.\n` +
+            `   File: ${CONFIG_PATH}`
+        );
+        process.exit(1);
+    }
+
+    // Проверяем, что в конфиге есть resize настройки
+    if (!originalConfig.resize) {
+        console.error(
+            `❌ Resize config is missing.\n` +
+            `   Please add 'resize' section to your config.`
+        );
+        process.exit(1);
+    }
+
+    // Создаём модифицированный конфиг для ресайза уже сконвертированных файлов
+    const targetFormat = (
+        originalConfig.convertation?.format ?? originalConfig.format ?? "webp"
+    ).toLowerCase();
+
+    const resizeConfig = {
+        ...originalConfig,
+        // Ищем файлы в целевом формате (уже сконвертированные)
+        convertation: {
+            ...originalConfig.convertation,
+            converted: `*.${targetFormat}`, // только файлы в целевом формате (без фигурных скобок для одного формата)
+            format: targetFormat, // оставляем тот же формат (не конвертируем)
+        },
+        // Принудительно включаем ресайз
+        needResize: true,
+        resize: originalConfig.resize,
+        // Используем removeOriginal из конфига
+        removeOriginal: originalConfig.removeOriginal ?? false,
+        // Флаг для режима ресайза (чтобы Pipeline знал, что нужно добавлять размер в имя)
+        isResizeMode: true,
+    };
+
+    console.log(`🔄 Resizing already converted ${targetFormat.toUpperCase()} files...`);
+    console.log(`   Resize config: ${JSON.stringify(originalConfig.resize, null, 2)}\n`);
+
+    const pipeline = new Pipeline(resizeConfig);
+    const stats = await pipeline.run();
+
+    console.log(`\n✅ Resize complete:`);
+    console.log(`   Total: ${stats.total}`);
+    console.log(`   Resized: ${stats.converted}`);
+    console.log(`   Skipped: ${stats.skipped}`);
+    console.log(`   Failed: ${stats.failed}`);
+} catch (e) {
+    if (e.code === "ERR_MODULE_NOT_FOUND" && e.message.includes("image-converter.config.mjs")) {
+        console.error(
+            `❌ Config file not found: ${CONFIG_PATH}\n` +
+            `   Please create 'image-converter.config.mjs' in the current directory.`
+        );
+    } else {
+        console.error(
+            "❌ Error:",
+            e.message
+        );
+        if (e.stack) {
+            console.error(e.stack);
+        }
+    }
+    process.exit(1);
+}

package/bin/watcher.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import chokidar from "chokidar";
 import path from "path";
-import { convertImages } from "../lib/converter.js";
+import { Pipeline } from "../lib/Pipeline.js";
 import { pathToFileURL } from "url";
 
 const configPath = path.resolve(process.cwd(), "image-converter.config.mjs");
@@ -9,48 +9,65 @@ const config = (await import(pathToFileURL(configPath).href)).default;
 
 const watchDir = config.dir || "public";
 const absWatchDir = path.resolve(process.cwd(), watchDir);
-const extensions = extractExtensions(config.converted ?? "*.{png,jpg,jpeg}");
+const extensions = extractExtensions(
+    config.convertation?.converted ?? config.converted ?? "*.{png,jpg,jpeg}"
+);
+const targetFormat = (
+    config.convertation?.format ?? config.format ?? "webp"
+).toLowerCase();
 
 const watchPath = absWatchDir;
 
 console.log(`👀 Watching for image changes on directory: ${watchPath}`);
 
+// Создаём Pipeline и запускаем воркеров в постоянном режиме
+const pipeline = new Pipeline(config);
+pipeline.startWorkers();
+
 let debounceTimeout;
+let pendingFiles = new Set();
 
 chokidar
-  .watch(absWatchDir, {
-    ignored: /(^|[\/\\])\../,
-    persistent: true,
-    ignoreInitial: config.ignoreOnStart ?? false,
-    awaitWriteFinish: {
-      stabilityThreshold: 1500,
-      pollInterval: 500,
-    },
-  })
-  .on("add", async (filePath) => {
-    const ext = path.extname(filePath).slice(1).toLowerCase(); // без точки
-    if (!extensions.includes(ext)) return;
-    if (ext === (config.targetFormat ?? "webp").toLowerCase()) return;
-
-    console.log(`➕ New image: ${filePath}`);
-    clearTimeout(debounceTimeout);
-    debounceTimeout = setTimeout(async () => {
-      try {
-        await convertImages({
-          dir: watchPath,
-          converted: config.converted ?? "*.{png,jpg,jpeg}",
-          format: config.format ?? "webp",
-          quality: config.quality ?? 80,
-          recursive: config.recursive ?? true,
-          removeOriginal: config.removeOriginal ?? false,
-        });
-      } catch (err) {
-        console.error("Error covertation:", err.message);
-      }
-    }, 1000);
-  });
+    .watch(absWatchDir, {
+        ignored: /(^|[\/\\])\../,
+        persistent: true,
+        ignoreInitial: config.ignoreOnStart ?? false,
+        awaitWriteFinish: {
+            stabilityThreshold: 1500,
+            pollInterval: 500,
+        },
+    })
+    .on("add", async (filePath) => {
+        const ext = path.extname(filePath).slice(1).toLowerCase();
+        if (!extensions.includes(ext)) return;
+        if (ext === targetFormat) return;
+
+        console.log(`➕ New image: ${filePath}`);
+        pendingFiles.add(filePath);
+
+        clearTimeout(debounceTimeout);
+        debounceTimeout = setTimeout(async () => {
+            // Обрабатываем все накопленные файлы
+            const filesToProcess = Array.from(pendingFiles);
+            pendingFiles.clear();
+
+            for (const file of filesToProcess) {
+                pipeline.enqueueFile(file);
+            }
+            // Воркеры уже работают, просто добавляем задачи в очередь
+        }, 1000);
+    });
+
+// Graceful shutdown
+process.on("SIGINT", async () => {
+    console.log("\n🛑 Stopping watcher...");
+    await pipeline.stop();
+    process.exit(0);
+});
 
 function extractExtensions(pattern) {
-  const match = pattern.match(/\*\.\{(.+?)\}/);
-  return match ? match[1].split(",").map((s) => s.trim().toLowerCase()) : [];
+    const match = pattern.match(/\*\.\{(.+?)\}/);
+    return match
+        ? match[1].split(",").map((s) => s.trim().toLowerCase())
+        : [];
 }

package/image-converter.config.mjs

@@ -1,9 +1,21 @@
 export default {
-  dir: "./public",
-  converted: "*.{png,jpg,jpeg}",
-  format: "webp",
-  quality: 80,
-  removeOriginal: true,
-  recursive: true,
-  ignoreOnStart: true,
+    // Основные настройки
+    dir: "./public",
+    removeOriginal: true,
+    recursive: true,
+    ignoreOnStart: true,
+    concurrency: 4,
+    convertation: {
+      converted: "*.{png,jpg,jpeg,tiff}", // png, jpg, jpeg, tiff, webp, avif
+      format: "webp", // png, jpeg, tiff, webp, avif
+      quality: 80, // 0-100
+  },
+    needResize: true, // true or false
+  resize: {
+      width: 1920, // 100-1000 or null
+      height: null, // 100-1000 or null
+      fit: "cover", // cover, contain, fill, inside, outside
+      position: "center", // center, top, bottom, left, right, top-left, top-right, bottom-left, bottom-right
+      withoutEnlargement: true, // true or false
+    },
 };

package/lib/ConvertImages.js

@@ -0,0 +1,68 @@
+import sharp from "sharp";
+
+/**
+ * Абстракция для конвертации форматов.
+ *
+ * Главное правило:
+ * - на вход можно дать путь/Buffer ИЛИ уже готовый sharp‑инстанс;
+ * - методы конверсии возвращают sharp‑инстанс;
+ * - .toBuffer() / .toFile() вызываются уже снаружи (в пайплайне).
+ */
+export class ConvertImages {
+  /**
+   * @param {string|Buffer|import("sharp").Sharp} input
+   * @param {Object} options
+   * @param {number} options.quality
+   */
+  constructor(input, options) {
+    this.quality = options.quality;
+
+    // Если нам уже дали sharp‑инстанс — просто переиспользуем его.
+    if (input && typeof input === "object" && typeof input.resize === "function") {
+      this.instance = input;
+    } else {
+      // Иначе считаем, что это путь или Buffer.
+      this.instance = sharp(input);
+    }
+  }
+
+  /**
+   * Конвертировать в WebP.
+   * @returns {import("sharp").Sharp}
+   */
+  toWebp() {
+    return this.instance.webp({ quality: this.quality });
+  }
+
+  /**
+   * Конвертировать в AVIF.
+   * @returns {import("sharp").Sharp}
+   */
+  toAvif() {
+    return this.instance.avif({ quality: this.quality });
+  }
+
+  /**
+   * Конвертировать в PNG.
+   * @returns {import("sharp").Sharp}
+   */
+  toPng() {
+    return this.instance.png({ quality: this.quality });
+  }
+
+  /**
+   * Конвертировать в JPEG.
+   * @returns {import("sharp").Sharp}
+   */
+  toJpg() {
+    return this.instance.jpeg({ quality: this.quality });
+  }
+
+  /**
+   * Конвертировать в TIFF.
+   * @returns {import("sharp").Sharp}
+   */
+  toTiff() {
+    return this.instance.tiff({ quality: this.quality });
+  }
+}

package/lib/CreateSrcSet.js

@@ -0,0 +1,60 @@
+export class CreateSrcSet {
+    // Resize modes
+    static RESIZE_MODES = {
+        COVER: "cover", // Fill the entire size, cropping excess
+        CONTAIN: "contain", // Contain fully, preserving proportions
+        FILL: "fill", // Stretch to size (distortion)
+        INSIDE: "inside", // Contain inside size (like contain)
+        OUTSIDE: "outside", // Cover outside (like cover)
+    };
+    constructor(filePath, options = {}) {
+        this.filePath = filePath;
+        this.format = options.format;
+        this.quality = options.quality;
+        this.resizeMode = options.resizeMode; // [{w:32,h:32}, {w:64,h:64}, {w:128,h:128}]
+        this.w = options.w;
+        this.h = options.h;
+    }
+    getOutputFileName(w, h) {
+        return `${this.nameWithoutExt}-${w}x${h}.${this.format}`;
+    }
+    createCover(w, h) {
+        return sharp(this.filePath).resize(w, h).toBuffer();
+    }
+    createContain(w, h) {
+        return sharp(this.filePath).resize(w, h).toBuffer();
+    }
+    createFill(w, h) {
+        return sharp(this.filePath).resize(w, h).toBuffer();
+    }
+    createInside(w, h) {
+        return sharp(this.filePath).resize(w, h).toBuffer();
+    }
+    createOutside(w, h) {
+        return sharp(this.filePath).resize(w, h).toBuffer();
+    }
+
+    create(w, h) {
+        switch (this.resizeMode) {
+            case this.RESIZE_MODES.COVER:
+                return this.createCover(w, h);
+            case this.RESIZE_MODES.CONTAIN:
+                return this.createContain(w, h);
+            case this.RESIZE_MODES.FILL:
+                return this.createFill(w, h);
+            case this.RESIZE_MODES.INSIDE:
+                return this.createInside(w, h);
+            case this.RESIZE_MODES.OUTSIDE:
+                return this.createOutside(w, h);
+            default:
+                throw new Error(
+                    `Invalid resize mode: ${this.resizeMode}`
+                );
+        }
+    }
+    createSrcSet() {
+        return this.resizeModes.map((mode) => {
+            return this.create(mode.w, mode.h);
+        });
+    }
+}