img-upload-kit 1.1.1 → 2.0.1

package/dist/cli.cjs

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -78,7 +77,8 @@ function normalizeImagePath(imageSrc, options = {}) {
       for (const pattern of patterns) {
         const match = cleanUrlNoQuery.match(pattern);
         if (match) {
-          const pathPart = match[match.length - 1];
+          const groups = match.slice(1).filter(Boolean);
+          const pathPart = groups.join("/");
           normalizedPath = "/" + pathPart.replace(/^\/+/, "");
           break;
         }
@@ -124,7 +124,6 @@ function normalizeImagePath(imageSrc, options = {}) {
 // src/cli/generator.ts
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_sharp4 = __toESM(require("sharp"), 1);
 
 // src/server/optimization/types.ts
 var BLUR_PLACEHOLDER_WIDTH = 128;
@@ -135,13 +134,28 @@ var EDGE_COLOR_FALLBACK = "#6B7280";
 var EDGE_WHITE_FALLBACK = "#F9FAFB";
 var WHITE_DOMINANCE_RATIO = 1.35;
 
+// src/server/optimization/loadSharp.ts
+var SHARP_MISSING_MESSAGE = "img-upload-kit/server requires `sharp` \u2014 run `npm i sharp`";
+var sharpPromise = null;
+function unwrapDefault(mod) {
+  const record = mod;
+  return record && record.default !== void 0 ? record.default : mod;
+}
+function loadSharp() {
+  if (!sharpPromise) {
+    sharpPromise = import("sharp").then(
+      (mod) => unwrapDefault(mod),
+      (error) => {
+        sharpPromise = null;
+        throw new Error(SHARP_MISSING_MESSAGE, { cause: error });
+      }
+    );
+  }
+  return sharpPromise;
+}
+
 // src/server/optimization/blurGenerator.ts
 var import_blurhash = require("blurhash");
-var import_lqip_modern = __toESM(require("lqip-modern"), 1);
-var import_sharp3 = __toESM(require("sharp"), 1);
-
-// src/server/optimization/edgeColorExtractor.ts
-var import_sharp2 = __toESM(require("sharp"), 1);
 
 // src/utils/color.ts
 function hexToRgb(hex) {
@@ -165,14 +179,14 @@ function rgbToHex(r, g, b) {
 }
 
 // src/server/optimization/colorHistogram.ts
-var import_sharp = __toESM(require("sharp"), 1);
 async function extractEnhancedColorFromBuffer(buffer, mode = "balanced") {
+  const sharp = await loadSharp();
   try {
-    const metadata = await (0, import_sharp.default)(buffer).metadata();
+    const metadata = await sharp(buffer).metadata();
     const maxSize = 400;
     const needsResize = metadata.width && metadata.height && (metadata.width > maxSize || metadata.height > maxSize);
     if (needsResize) {
-      const resized = await (0, import_sharp.default)(buffer).resize(maxSize, maxSize, {
+      const resized = await sharp(buffer).resize(maxSize, maxSize, {
         fit: "inside",
         kernel: "lanczos3",
         withoutEnlargement: true
@@ -184,7 +198,7 @@ async function extractEnhancedColorFromBuffer(buffer, mode = "balanced") {
         mode
       );
     }
-    const raw = await (0, import_sharp.default)(buffer).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    const raw = await sharp(buffer).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
     return extractDominantColorHistogramAdvanced(
       raw.data,
       raw.info.width,
@@ -192,7 +206,7 @@ async function extractEnhancedColorFromBuffer(buffer, mode = "balanced") {
       mode
     );
   } catch {
-    const stats = await (0, import_sharp.default)(buffer).resize(64, 64, { fit: "cover", kernel: "lanczos3" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    const stats = await sharp(buffer).resize(64, 64, { fit: "cover", kernel: "lanczos3" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
     return extractDominantColorHistogram(stats.data);
   }
 }
@@ -311,8 +325,9 @@ function extractDominantColorHistogram(data) {
 
 // src/server/optimization/edgeColorExtractor.ts
 async function extractEdgeColorsFromBuffer(buffer) {
+  const sharp = await loadSharp();
   try {
-    const sample = await (0, import_sharp2.default)(buffer).resize(400, 400, {
+    const sample = await sharp(buffer).resize(400, 400, {
       fit: "inside",
       kernel: "lanczos3",
       withoutEnlargement: true
@@ -452,46 +467,73 @@ function blendEdgeColors(edgeColors) {
 }
 
 // src/server/optimization/blurGenerator.ts
-async function encodeBlurHashString(buffer, componentX = 4, componentY = 3) {
-  const { data, info } = await (0, import_sharp3.default)(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  const clampedX = Math.max(1, Math.min(Math.round(componentX), info.width, 9));
-  const clampedY = Math.max(1, Math.min(Math.round(componentY), info.height, 9));
+function encodeRawBlurHash(data, width, height, componentX = 4, componentY = 3) {
+  const clampedX = Math.max(1, Math.min(Math.round(componentX), width, 9));
+  const clampedY = Math.max(1, Math.min(Math.round(componentY), height, 9));
   return (0, import_blurhash.encode)(
     new Uint8ClampedArray(data),
-    info.width,
-    info.height,
+    width,
+    height,
     clampedX,
     clampedY
   );
 }
+async function encodeBlurHashString(buffer, componentX = 4, componentY = 3) {
+  const sharp = await loadSharp();
+  const { data, info } = await sharp(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return encodeRawBlurHash(
+    data,
+    info.width,
+    info.height,
+    componentX,
+    componentY
+  );
+}
 async function generateBlurPlaceholder(buffer, options = {}) {
   const targetWidth = options.width ?? BLUR_PLACEHOLDER_WIDTH;
   const fallbackWidth = options.fallbackWidth ?? BLUR_PLACEHOLDER_FALLBACK_WIDTH;
   const quality = options.quality ?? BLUR_PLACEHOLDER_QUALITY;
   const maxChars = options.maxDataUrlChars ?? BLUR_PLACEHOLDER_MAX_CHARS;
+  const sharp = await loadSharp();
   try {
     let processBuffer = buffer;
     const isSvg = /<svg[\s>]/i.test(buffer.toString("utf8", 0, 1024));
     if (isSvg) {
       const normalizedSvg = buffer.toString("utf8").replace(/<svg\b/gi, "<svg").replace(/<\/svg\s*>/gi, "</svg>");
-      processBuffer = await (0, import_sharp3.default)(Buffer.from(normalizedSvg, "utf8")).resize(targetWidth, targetWidth, { fit: "inside" }).png().toBuffer();
+      processBuffer = Buffer.from(normalizedSvg, "utf8");
     }
-    const buildPlaceholder = (width, q) => (0, import_lqip_modern.default)(processBuffer, {
-      outputFormat: "webp",
-      resize: width,
-      outputOptions: { quality: q, effort: 6, smartSubsample: true }
-    });
-    let result = await buildPlaceholder(targetWidth, quality);
-    if (result.metadata.dataURIBase64.length > maxChars) {
-      result = await buildPlaceholder(fallbackWidth, quality);
+    const baseSize = Math.max(targetWidth, 128);
+    const rawSample = await sharp(processBuffer).rotate().resize(baseSize, baseSize, { fit: "inside", withoutEnlargement: true }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    const rawInput = {
+      raw: {
+        width: rawSample.info.width,
+        height: rawSample.info.height,
+        channels: 4
+      }
+    };
+    const buildPlaceholderDataUrl = async (width) => {
+      const webpBuffer = await sharp(rawSample.data, rawInput).resize(width, width, { fit: "inside", withoutEnlargement: true }).webp({ quality, effort: 6, smartSubsample: true }).toBuffer();
+      return `data:image/webp;base64,${webpBuffer.toString("base64")}`;
+    };
+    let dataURL = await buildPlaceholderDataUrl(targetWidth);
+    if (dataURL.length > maxChars) {
+      dataURL = await buildPlaceholderDataUrl(fallbackWidth);
     }
-    const dataURL = result.metadata.dataURIBase64;
-    const edgeColors = await extractEdgeColorsFromBuffer(processBuffer);
+    const edgeColors = computeEdgeColorSet(
+      rawSample.data,
+      rawSample.info.width,
+      rawSample.info.height
+    );
     const color = blendEdgeColors(edgeColors);
     let blurHash;
     if (options.includeBlurHash) {
       try {
-        blurHash = await encodeBlurHashString(processBuffer);
+        const hashSample = rawSample.info.width <= 32 && rawSample.info.height <= 32 ? rawSample : await sharp(rawSample.data, rawInput).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+        blurHash = encodeRawBlurHash(
+          hashSample.data,
+          hashSample.info.width,
+          hashSample.info.height
+        );
       } catch {
         blurHash = void 0;
       }
@@ -506,7 +548,8 @@ async function generateBlurPlaceholder(buffer, options = {}) {
   }
 }
 async function generateFallbackBlur(buffer, includeBlurHash) {
-  const tinyBuffer = await (0, import_sharp3.default)(buffer).resize(64, 64, { fit: "cover", kernel: "lanczos3" }).blur(1).webp({
+  const sharp = await loadSharp();
+  const tinyBuffer = await sharp(buffer).resize(64, 64, { fit: "cover", kernel: "lanczos3" }).blur(1).webp({
     quality: 75,
     effort: 6,
     smartSubsample: false
@@ -526,42 +569,184 @@ async function generateFallbackBlur(buffer, includeBlurHash) {
 }
 
 // src/server/semaphore.ts
+var SemaphoreQueueFullError = class extends Error {
+  status = 503;
+  constructor(message = "Server upload queue is full. Please try again later.") {
+    super(message);
+    this.name = "SemaphoreQueueFullError";
+  }
+};
+function createAbortError(signal) {
+  if (signal?.reason instanceof Error) {
+    return signal.reason;
+  }
+  const err = new Error(
+    typeof signal?.reason === "string" ? signal.reason : "Operation aborted"
+  );
+  err.name = "AbortError";
+  return err;
+}
 var AsyncSemaphore = class {
-  constructor(concurrency) {
+  constructor(concurrency, options) {
     this.concurrency = concurrency;
     if (concurrency < 1) {
       throw new Error("AsyncSemaphore concurrency must be >= 1");
     }
+    if (typeof options === "number") {
+      this.maxQueue = options;
+    } else if (options && typeof options === "object") {
+      this.maxQueue = options.maxQueue;
+    }
   }
   concurrency;
   activeCount = 0;
+  maxQueue;
   queue = [];
-  async run(task) {
-    await this.acquire();
+  get active() {
+    return this.activeCount;
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  async run(task, options = {}) {
+    const { signal, timeoutMs, label = "Semaphore task" } = options;
+    await this.acquire(signal);
+    let rawTaskPromise;
     try {
-      return await task();
-    } finally {
+      rawTaskPromise = Promise.resolve().then(task);
+    } catch (syncError) {
       this.release();
+      throw syncError;
     }
+    let released = false;
+    const releaseOnce = () => {
+      if (!released) {
+        released = true;
+        this.release();
+      }
+    };
+    void rawTaskPromise.then(
+      () => releaseOnce(),
+      (err) => {
+        const pending = err && typeof err === "object" && "pendingTask" in err ? err.pendingTask : void 0;
+        if (pending && typeof pending.then === "function") {
+          void pending.then(releaseOnce, releaseOnce);
+        } else {
+          releaseOnce();
+        }
+      }
+    );
+    let callerPromise = rawTaskPromise;
+    if (timeoutMs !== void 0 && timeoutMs > 0) {
+      callerPromise = withTimeout(callerPromise, timeoutMs, label);
+    }
+    if (signal) {
+      callerPromise = raceWithAbort(callerPromise, signal);
+    }
+    return callerPromise;
   }
-  acquire() {
+  acquire(signal) {
+    if (signal?.aborted) {
+      return Promise.reject(createAbortError(signal));
+    }
     if (this.activeCount < this.concurrency) {
       this.activeCount += 1;
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
-      this.queue.push(() => {
-        this.activeCount += 1;
-        resolve();
-      });
+    if (this.maxQueue !== void 0 && this.queue.length >= this.maxQueue) {
+      return Promise.reject(new SemaphoreQueueFullError());
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        const idx = this.queue.indexOf(entry);
+        if (idx !== -1) {
+          this.queue.splice(idx, 1);
+        }
+        entry.cancel(createAbortError(signal));
+      };
+      const entry = {
+        grant: () => {
+          signal?.removeEventListener("abort", onAbort);
+          this.activeCount += 1;
+          resolve();
+        },
+        cancel: (reason) => {
+          signal?.removeEventListener("abort", onAbort);
+          reject(reason);
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.queue.push(entry);
     });
   }
   release() {
     this.activeCount = Math.max(0, this.activeCount - 1);
     const next = this.queue.shift();
-    next?.();
+    next?.grant();
   }
 };
+function raceWithAbort(task, signal) {
+  if (signal.aborted) {
+    const err = createAbortError(signal);
+    err.pendingTask = task.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return Promise.reject(err);
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      const err = createAbortError(signal);
+      err.pendingTask = task.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      reject(err);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    task.then(
+      (val) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(val);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+async function withTimeout(task, timeoutMs, label) {
+  let timeoutHandle = null;
+  const settledTask = task.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  try {
+    return await Promise.race([
+      task,
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          const err = new Error(
+            `${label} timed out after ${timeoutMs}ms`
+          );
+          err.pendingTask = settledTask;
+          reject(err);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+  }
+}
 
 // src/cli/scanner.ts
 var import_promises = __toESM(require("fs/promises"), 1);
@@ -633,22 +818,27 @@ async function loadExistingHashes(manifestPath) {
 function canReuseCachedEntry(entry, file, includeMedium) {
   if (!entry || typeof entry !== "object") return false;
   if (!entry.hash || !entry.color || !entry.variants?.small) return false;
-  if (entry.metadata) {
-    if (entry.metadata.size && entry.metadata.size !== String(file.size)) {
-      return false;
-    }
-    if (entry.metadata.mtimeMs && entry.metadata.mtimeMs !== String(Math.round(file.mtimeMs))) {
-      return false;
-    }
-    if (includeMedium && !entry.variants.medium) return false;
+  if (!entry.metadata || !entry.metadata.size || !entry.metadata.mtimeMs) {
+    return false;
+  }
+  if (entry.metadata.size !== String(file.size)) {
+    return false;
   }
+  if (entry.metadata.mtimeMs !== String(Math.round(file.mtimeMs))) {
+    return false;
+  }
+  if (includeMedium && !entry.variants.medium) return false;
   return true;
 }
 async function resolveImageDimensions(buffer, isSvg) {
-  const metadata = await (0, import_sharp4.default)(buffer).metadata();
+  const sharp = await loadSharp();
+  const metadata = await sharp(buffer).metadata();
   let { width, height } = metadata;
   if ((!width || !height) && isSvg) {
-    const match = buffer.toString("utf8").match(/viewBox\s*=\s*["']\s*([\d.-]+)\s+([\d.-]+)\s+([\d.-]+)\s+([\d.-]+)\s*["']/i);
+    const svgText = buffer.toString("utf8");
+    const match = svgText.match(
+      /viewBox\s*=\s*["']\s*([\d.-]+)[\s,]+([\d.-]+)[\s,]+([\d.-]+)[\s,]+([\d.-]+)\s*["']/i
+    );
     if (match) {
       width = Math.round(Number.parseFloat(match[3]));
       height = Math.round(Number.parseFloat(match[4]));
@@ -673,8 +863,8 @@ async function generateBlurManifest(imagesDir, manifestFile, options = {}) {
   await Promise.all(
     files.map(
       (file) => semaphore.run(async () => {
+        const prior = force ? void 0 : existingHashes[file.relativeKey];
         try {
-          const prior = force ? void 0 : existingHashes[file.relativeKey];
           if (canReuseCachedEntry(prior, file, includeMedium)) {
             generatedEntries.set(file.relativeKey, prior);
             cached += 1;
@@ -709,8 +899,16 @@ async function generateBlurManifest(imagesDir, manifestFile, options = {}) {
             }
           });
           processed += 1;
-        } catch {
+        } catch (err) {
           failed += 1;
+          const existing = existingHashes[file.relativeKey];
+          if (existing) {
+            generatedEntries.set(file.relativeKey, existing);
+          }
+          const reason = err instanceof Error ? err.message : String(err);
+          console.warn(
+            `Warning: Failed to generate blur manifest entry for "${file.relativeKey}": ${reason}`
+          );
         } finally {
           done += 1;
           options.onProgress?.(done, total, file.relativeKey);
@@ -888,6 +1086,7 @@ async function generateHealthReport(imagesDir, manifestFile) {
 }
 
 // src/cli/commands.ts
+var CLI_VERSION = "2.0.0".length > 0 ? "2.0.0" : "2.0.0";
 var DEFAULT_IMAGES_DIR = "public/images";
 var DEFAULT_MANIFEST_FILE = "src/blur-hashes.json";
 function findManifestEntry(hashes, imageKey) {
@@ -905,7 +1104,7 @@ function findManifestEntry(hashes, imageKey) {
 }
 function createCliProgram() {
   const program = new import_commander.Command();
-  program.name("img-upload-kit").description("LQIP, BlurHash, and dominant color manifest CLI tooling").version("1.1.1");
+  program.name("img-upload-kit").description("LQIP, BlurHash, and dominant color manifest CLI tooling").version(CLI_VERSION);
   program.command("generate").description("Scan an image directory and generate a blur-hashes JSON manifest").option("-d, --dir <dir>", "Source images directory", DEFAULT_IMAGES_DIR).option("-o, --out <file>", "Output manifest JSON path", DEFAULT_MANIFEST_FILE).option("-f, --force", "Force regenerate all entries ignoring cache", false).option("-c, --concurrency <n>", "Max parallel processing workers", "4").option("--no-medium", "Skip generating medium (128px) LQIP variants").action(
     async (opts) => {
       const concurrency = Math.max(1, Number.parseInt(opts.concurrency, 10) || 4);
@@ -929,7 +1128,7 @@ function createCliProgram() {
     }
     console.log(`Manifest is valid (${result.totalEntries} entries).`);
   });
-  program.command("sync").description("Check whether disk images and manifest entries are in sync").option("-d, --dir <dir>", "Source images directory", DEFAULT_IMAGES_DIR).option("-f, --file <file>", "Manifest JSON path", DEFAULT_MANIFEST_FILE).option("--fix", "Generate missing blur manifest entries automatically", false).action(async (opts) => {
+  program.command("sync").description("Check whether disk images and manifest entries are in sync").option("-d, --dir <dir>", "Source images directory", DEFAULT_IMAGES_DIR).option("-f, --file <file>", "Manifest JSON path", DEFAULT_MANIFEST_FILE).option("--fix", "Generate missing and remove orphaned blur manifest entries automatically", false).action(async (opts) => {
     const sync = await autoSyncCheck(opts.dir, opts.file);
     if (sync.inSync) {
       console.log(`In sync (${sync.totalEntries} entries).`);
@@ -938,12 +1137,21 @@ function createCliProgram() {
     console.log(
       `Out of sync: ${sync.missingKeys.length} missing, ${sync.orphanedKeys.length} orphaned.`
     );
-    if (opts.fix && sync.missingKeys.length > 0) {
-      const result = await generateBlurManifest(opts.dir, opts.file);
-      console.log(
-        `Synced manifest (processed: ${result.processed}, cached: ${result.cached}).`
-      );
-      return;
+    if (opts.fix) {
+      if (sync.missingKeys.length > 0) {
+        const result = await generateBlurManifest(opts.dir, opts.file);
+        console.log(
+          `Synced manifest (processed: ${result.processed}, cached: ${result.cached}, removed orphans: ${sync.orphanedKeys.length}).`
+        );
+        return;
+      }
+      if (sync.orphanedKeys.length > 0) {
+        const cleaned = await cleanupOrphanedHashes(opts.dir, opts.file);
+        console.log(
+          `Synced manifest (removed ${cleaned.removedCount} orphaned entries).`
+        );
+        return;
+      }
     }
     if (!opts.fix) process.exitCode = 1;
   });
@@ -1016,17 +1224,6 @@ async function runCli(argv) {
   const isUserArgs = argv.length === 0 || CLI_SUBCOMMANDS.has(argv[0]) || argv[0].startsWith("-");
   await program.parseAsync(argv, isUserArgs ? { from: "user" } : void 0);
 }
-function isDirectCliExecution(entryArg) {
-  if (!entryArg) return false;
-  const normalized = entryArg.replace(/\\/g, "/");
-  return normalized === "cli.js" || normalized === "cli.cjs" || normalized.endsWith("/cli.js") || normalized.endsWith("/cli.cjs") || normalized.endsWith("/cli/index.ts") || normalized.endsWith("/bin/img-upload-kit") || normalized.endsWith("/.bin/img-upload-kit") || normalized.endsWith("/bin/image-upload-kit") || normalized.endsWith("/.bin/image-upload-kit") || normalized.endsWith("/bin/blur-cli") || normalized.endsWith("/.bin/blur-cli");
-}
-if (typeof process !== "undefined" && isDirectCliExecution(process.argv?.[1])) {
-  void runCli().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exitCode = 1;
-  });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   IGNORED_DIRECTORIES,