auto-image-converter 2.1.1 → 2.2.0

package/lib/Queue.js

@@ -0,0 +1,41 @@
+export class Queue {
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this.size = 0;
+    }
+
+    enqueue(task) {
+        const node = { value: task, next: null };
+        if (this.tail) {
+            this.tail.next = node;
+            this.tail = node;
+        } else {
+            this.head = node;
+            this.tail = node;
+        }
+        this.size++;
+    }
+
+    dequeue() {
+        if (!this.head) return null;
+        const value = this.head.value;
+        this.head = this.head.next;
+        if (!this.head) {
+            this.tail = null;
+        }
+        this.size--;
+        return value;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    peek() {
+        return this.head?.value ?? null;
+    }
+    clear() {
+        this.head = null;
+        this.tail = null;
+        this.size = 0;
+    }
+}

package/lib/ResizeImages.js

@@ -0,0 +1,105 @@
+import sharp from "sharp";
+
+/**
+ * Простая обёртка над sharp().resize() под наши кейсы:
+ * - уменьшить по ширине;
+ * - уменьшить по высоте;
+ * - вписать в прямоугольник с нужным соотношением сторон;
+ * во всех случаях можно контролировать fit, position, withoutEnlargement.
+ *
+ * ВНИМАНИЕ: методы возвращают sharp‑инстанс.
+ * Снаружи нужно завершать цепочку, например .toBuffer() или .toFile().
+ */
+export class ResizeImages {
+  /**
+   * @param {string|Buffer} source - путь к файлу или Buffer с изображением
+   * @param {Object} [defaultOptions]
+   * @param {"cover"|"contain"|"fill"|"inside"|"outside"} [defaultOptions.fit]
+   * @param {string} [defaultOptions.position]
+   * @param {boolean} [defaultOptions.withoutEnlargement]
+   */
+  constructor(source, defaultOptions = {}) {
+    this.source = source;
+
+    // Базовые дефолты, чтобы "просто работало" под типичный кейс:
+    this.defaultOptions = {
+      fit: "inside",
+      position: "center",
+      withoutEnlargement: true,
+      ...defaultOptions,
+    };
+  }
+
+  /**
+   * Внутренний помощник: склеиваем дефолты и конкретные опции.
+   * @param {Object} extra
+   * @returns {import("sharp").ResizeOptions}
+   * @private
+   */
+  _buildOptions(extra = {}) {
+    return {
+      ...this.defaultOptions,
+      ...extra,
+    };
+  }
+
+  /**
+   * Уменьшить изображение до нужной ширины (высота по пропорциям).
+   *
+   * @param {number} width
+   * @param {Object} [options]
+   * @param {"cover"|"contain"|"fill"|"inside"|"outside"} [options.fit]
+   * @param {string} [options.position]
+   * @param {boolean} [options.withoutEnlargement]
+   * @returns {import("sharp").Sharp}
+   */
+  byWidth(width, options = {}) {
+    const resizeOptions = this._buildOptions({
+      width,
+      ...options,
+    });
+
+    return sharp(this.source).resize(resizeOptions);
+  }
+
+  /**
+   * Уменьшить изображение до нужной высоты (ширина по пропорциям).
+   *
+   * @param {number} height
+   * @param {Object} [options]
+   * @param {"cover"|"contain"|"fill"|"inside"|"outside"} [options.fit]
+   * @param {string} [options.position]
+   * @param {boolean} [options.withoutEnlargement]
+   * @returns {import("sharp").Sharp}
+   */
+  byHeight(height, options = {}) {
+    const resizeOptions = this._buildOptions({
+      height,
+      ...options,
+    });
+
+    return sharp(this.source).resize(resizeOptions);
+  }
+
+  /**
+   * Вписать/кадрировать изображение в прямоугольник (конкретное соотношение сторон).
+   * Обычно используется под 16:9, 1:1 и т.п.
+   *
+   * @param {number} width
+   * @param {number} height
+   * @param {Object} [options]
+   * @param {"cover"|"contain"|"fill"|"inside"|"outside"} [options.fit] - cover (обрезать лишнее) или contain (вписать с полями)
+   * @param {string} [options.position] - центр кадрирования при fit: "cover"
+   * @param {boolean} [options.withoutEnlargement] - запрещать ли растягивание маленьких исходников
+   * @returns {import("sharp").Sharp}
+   */
+  toBox(width, height, options = {}) {
+    const resizeOptions = this._buildOptions({
+      width,
+      height,
+      ...options,
+    });
+
+    return sharp(this.source).resize(resizeOptions);
+  }
+}

package/lib/converter.js

@@ -9,64 +9,149 @@ const supportedExt = [".png", ".jpg", ".jpeg"];
 
 const processingFiles = new Set();
 
-async function safeUnlink(file, retries = 3, delayMs = 200) {
-  for (let i = 0; i < retries; i++) {
+async function safeUnlink(
+    file,
+    retries = 3,
+    delayMs = 200
+) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            await fs.unlink(file);
+            return;
+        } catch (err) {
+            if (i === retries - 1) throw err;
+            await new Promise((res) =>
+                setTimeout(res, delayMs)
+            );
+        }
+    }
+}
+
+async function getUniqueOutputPath(outFile, newBufferSize) {
     try {
-      await fs.unlink(file);
-      return;
-    } catch (err) {
-      if (i === retries - 1) throw err;
-      await new Promise((res) => setTimeout(res, delayMs));
+        const existingStat = await fs.stat(outFile);
+
+        // Если размеры совпадают - скорее всего это дубликат
+        if (existingStat.size === newBufferSize) {
+            return null; // Сигнал пропустить файл
+        }
+
+        // Размеры разные - нужно уникальное имя
+        const dir = path.dirname(outFile);
+        const ext = path.extname(outFile);
+        const nameWithoutExt = path.basename(outFile, ext);
+
+        let counter = 1;
+        let uniquePath;
+
+        while (true) {
+            uniquePath = path.join(
+                dir,
+                `${nameWithoutExt}(${counter})${ext}`
+            );
+
+            try {
+                const stat = await fs.stat(uniquePath);
+                // Если файл с таким именем существует и размер совпадает - это дубликат
+                if (stat.size === newBufferSize) {
+                    return null;
+                }
+                counter++;
+            } catch {
+                // Файл не существует - можем использовать это имя
+                return uniquePath;
+            }
+        }
+    } catch {
+        // Файл не существует - используем оригинальное имя
+        return outFile;
     }
-  }
 }
 
 export async function convertImages({
-  dir,
-  converted,
-  format,
-  quality,
-  recursive,
-  removeOriginal,
+    dir,
+    converted,
+    format,
+    quality,
+    recursive,
+    removeOriginal,
 }) {
-  const rawPattern = recursive
-    ? path.join(dir, "**", converted)
-    : path.join(dir, converted);
+    const rawPattern = recursive
+        ? path.join(dir, "**", converted)
+        : path.join(dir, converted);
 
-  const pattern = rawPattern.split(path.sep).join(path.posix.sep);
-  const files = await fg(pattern, { caseSensitiveMatch: false });
+    const pattern = rawPattern
+        .split(path.sep)
+        .join(path.posix.sep);
+    const files = await fg(pattern, {
+        caseSensitiveMatch: false,
+    });
 
-  for (const file of files) {
-    if (processingFiles.has(file)) continue;
-    processingFiles.add(file);
+    for (const file of files) {
+        if (processingFiles.has(file)) continue;
+        processingFiles.add(file);
 
-    try {
-      const ext = path.extname(file);
-      const outFile = file.replace(ext, `.${format}`);
-
-      // Игнорируем файлы, которые уже в целевом формате
-      if (ext.toLowerCase() === `.${format.toLowerCase()}`) {
-        processingFiles.delete(file);
-        continue;
-      }
-
-      const image = sharp(file);
-      const buffer =
-        format === "webp"
-          ? await image.webp({ quality }).toBuffer()
-          : await image.avif({ quality }).toBuffer();
-
-      await fs.writeFile(outFile, buffer);
-
-      if (removeOriginal) {
-        await safeUnlink(file);
-      }
-
-      console.log(`✓ ${file} → ${outFile}`);
-    } catch (err) {
-      console.error("Error covertation:", err.message);
-    } finally {
-      processingFiles.delete(file);
+        try {
+            const ext = path.extname(file);
+            let outFile = file.replace(ext, `.${format}`);
+
+            // Игнорируем файлы, которые уже в целевом формате
+            if (
+                ext.toLowerCase() ===
+                `.${format.toLowerCase()}`
+            ) {
+                processingFiles.delete(file);
+                continue;
+            }
+
+            const image = sharp(file);
+            const buffer =
+                format === "webp"
+                    ? await image
+                          .webp({ quality })
+                          .toBuffer()
+                    : await image
+                          .avif({ quality })
+                          .toBuffer();
+
+            // Проверяем, не существует ли уже файл с таким именем
+            const finalPath = await getUniqueOutputPath(
+                outFile,
+                buffer.length
+            );
+
+            if (finalPath === null) {
+                // Файл с таким же размером уже существует - это дубликат
+                console.log(
+                    `⊘ ${file} → skipped (duplicate)`
+                );
+
+                // Удаляем оригинал-дубликат, если включена опция
+                if (removeOriginal) {
+                    await safeUnlink(file);
+                    console.log(`🗑️  ${file} → deleted`);
+                }
+
+                processingFiles.delete(file);
+                continue;
+            }
+
+            outFile = finalPath;
+
+            await fs.writeFile(outFile, buffer);
+
+            if (removeOriginal) {
+                await safeUnlink(file);
+            }
+
+            console.log(`✓ ${file} → ${outFile}`);
+        } catch (err) {
+            console.error(
+                "Error covertation:",
+                err.message
+            );
+        } finally {
+            processingFiles.delete(file);
+        }
     }
-  }
 }

package/lib/pipelines/ConvertationPipeline.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import fg from "fast-glob";
+import { Queue } from "../Queue.js";
+import { ConvertationStep } from "../steps/ConvertationStep.js";
+import { MarkerFile } from "../MarkerFile.js";
+
+export class ConvertationPipeline {
+    constructor(config) {
+        this.config = config;
+
+        const stepConfig =
+            config.modules?.convertation ||
+            config.convertation ||
+            config;
+
+        // Добавляем глобальные параметры в step конфиг
+        const mergedConfig = {
+            ...stepConfig,
+            removeOriginal:
+                stepConfig.removeOriginal !== undefined
+                    ? stepConfig.removeOriginal
+                    : config.removeOriginal,
+        };
+
+        this.step = new ConvertationStep(mergedConfig);
+        this.queue = new Queue();
+        this.processing = new Set();
+        this.stats = {
+            total: 0,
+            converted: 0,
+            skipped: 0,
+            failed: 0,
+        };
+    }
+
+    // Основной метод - запуск конвертации всех файлов
+    async run() {
+        console.log("🚀 Starting convertation pipeline...");
+
+        // 1. Собираем файлы
+        const files = await this.collectFiles();
+        console.log(
+            `📁 Found ${files.length} files to process`
+        );
+
+        if (files.length === 0) {
+            console.log("✅ No files to convert");
+            return this.stats;
+        }
+
+        // 2. Добавляем в очередь
+        this.enqueueFiles(files);
+
+        // 3. Обрабатываем с параллелизмом
+        await this.processQueue();
+
+        // 4. Выводим итоговую статистику
+        this.printStats();
+
+        return this.stats;
+    }
+
+    // Сбор файлов по конфигу
+    async collectFiles() {
+        const dir = this.config.dir || process.cwd();
+        const converted =
+            this.config.modules?.convertation?.converted ||
+            this.config.convertation?.converted ||
+            this.config.converted ||
+            "*.{png,jpg,jpeg}";
+        const recursive = this.config.recursive !== false;
+
+        const absDir = path.resolve(process.cwd(), dir);
+        const pattern = recursive
+            ? path.join(absDir, "**", converted)
+            : path.join(absDir, converted);
+
+        const unified = pattern
+            .split(path.sep)
+            .join(path.posix.sep);
+
+        return fg(unified, { caseSensitiveMatch: false });
+    }
+
+    // Добавление файлов в очередь
+    enqueueFiles(files) {
+        for (const file of files) {
+            this.enqueueFile(file);
+        }
+    }
+
+    // Добавление одного файла в очередь
+    enqueueFile(filePath) {
+        if (!filePath || this.processing.has(filePath)) {
+            return false;
+        }
+
+        this.processing.add(filePath);
+        this.queue.enqueue((workerId) =>
+            this.processFile(filePath, workerId)
+        );
+        this.stats.total++;
+        return true;
+    }
+
+    // Обработка очереди с параллелизмом
+    async processQueue() {
+        const concurrency = this.config.concurrency || 4;
+        const workers = Array.from(
+            { length: concurrency },
+            (_, index) => this.workerLoop(index + 1)
+        );
+
+        await Promise.all(workers);
+    }
+
+    // Рабочий цикл для обработки задач
+    async workerLoop(workerId) {
+        while (!this.queue.isEmpty()) {
+            const task = this.queue.dequeue();
+            if (!task) break;
+
+            try {
+                await task(workerId);
+            } catch (err) {
+                console.error(
+                    `[Worker ${workerId}] ❌ Error:`,
+                    err.message
+                );
+            }
+        }
+    }
+
+    // Обработка одного файла
+    async processFile(filePath, workerId) {
+        const workerPrefix = workerId
+            ? `[Worker ${workerId}]`
+            : "";
+
+        try {
+            const result = await this.step.execute(
+                filePath
+            );
+
+            if (result.success) {
+                this.stats.converted++;
+                console.log(
+                    `${workerPrefix} ✓ ${result.originalPath} → ${result.outputPath}`
+                );
+            } else if (result.skipped) {
+                this.stats.skipped++;
+                console.log(
+                    `${workerPrefix} ⊘ ${result.originalPath} → ${result.reason}`
+                );
+            } else {
+                this.stats.failed++;
+                console.error(
+                    `${workerPrefix} ❌ ${result.originalPath}: ${result.error}`
+                );
+            }
+        } catch (err) {
+            this.stats.failed++;
+            console.error(
+                `${workerPrefix} ❌ ${filePath}:`,
+                err.message
+            );
+        } finally {
+            this.processing.delete(filePath);
+        }
+    }
+
+    // Вывод итоговой статистики
+    printStats() {
+        console.log("\n📊 Convertation completed:");
+        console.log(`   Total:     ${this.stats.total}`);
+        console.log(
+            `   Converted: ${this.stats.converted}`
+        );
+        console.log(`   Skipped:   ${this.stats.skipped}`);
+        console.log(`   Failed:    ${this.stats.failed}`);
+    }
+}