@depup/sharp-cli 5.3.0-depup.0 → 6.1.0-depup.0

package/lib/constants.js

@@ -21,14 +21,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// Strict mode.
-"use strict";
-
 // Package modules.
-const sharp = require("sharp");
+import sharp from "sharp";
 
 // Exports.
-module.exports = {
+export default {
   BLEND: Object.keys(sharp.blend),
   BOOL: Object.keys(sharp.bool),
   CHANNEL: ["red", "green", "blue", "alpha"],
@@ -38,7 +35,7 @@ module.exports = {
   EXTEND_WITH: ["background", "copy", "repeat", "mirror"],
   FAIL_ON: ["none", "truncated", "error", "warning"],
   FIT: Object.keys(sharp.fit),
-  FORMAT: ["avif", "gif", "heif", "jpeg", "jpg", "png", "tiff", "webp"],
+  FORMAT: ["avif", "gif", "heif", "jpeg", "png", "tiff", "webp"],
   GRAVITY: Object.keys(sharp.gravity),
   HEIF_COMPRESSION: ["hevc", "av1"],
   INTERPOLATORS: Object.keys(sharp.interpolators),
@@ -60,4 +57,5 @@ module.exports = {
     "zstd",
   ],
   TIFF_PREDICTOR: ["float", "horizontal", "none"],
+  TUNE: ["auto", "iq", "psnr", "ssim"],
 };

package/lib/convert.js

@@ -21,21 +21,18 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// Strict mode.
-"use strict";
-
 // Standard lib.
-const fs = require("fs");
-const path = require("path");
-const { pipeline } = require("stream/promises");
+import { createReadStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
 
 // Package modules.
-const { globSync } = require("glob");
-const isDirectory = require("is-directory");
-const sharp = require("sharp");
+import { globSync } from "glob";
+import sharp from "sharp";
 
 // Local modules.
-const queue = require("./queue");
+import { drain, isDirectory } from "./utils.js";
 
 // Configure.
 const EXTENSIONS = {
@@ -48,69 +45,136 @@ const EXTENSIONS = {
   tiff: ".tiff",
   webp: ".webp",
 };
+const FORMATS = {
+  ".avif": "avif",
+  ".gif": "gif",
+  ".jpg": "jpeg",
+  ".jpeg": "jpeg",
+  ".png": "png",
+  ".tif": "tiff",
+  ".tiff": "tiff",
+  ".webp": "webp",
+};
+
+// Resolve the non-magic portion of a glob to use as its relative path root.
+const getGlobRoot = (pattern) => {
+  const absolute = path.resolve(pattern);
+  const magicIndex = absolute.search(/[*?[{(]/);
+  if (magicIndex === -1) {
+    return path.dirname(absolute);
+  }
+
+  const prefix = absolute.slice(0, magicIndex);
+  return prefix.endsWith(path.sep)
+    ? path.resolve(prefix)
+    : path.dirname(path.resolve(prefix));
+};
 
 // Exports.
-module.exports = {
+export default {
   // Convert a list of files.
-  files: (input, output, options) => {
+  files: async (input, output, context) => {
     // Resolve files.
-    const files = input.reduce((list, input) => {
-      return list.concat(globSync(input, { absolute: true }));
-    }, []);
-
+    const files = input.flatMap((pattern) => {
+      const root = getGlobRoot(pattern);
+      return globSync(pattern, { absolute: true }).map((src) => ({
+        root,
+        src,
+      }));
+    });
     if (files.length === 0) {
-      return Promise.reject(new Error("No input files"));
+      throw new Error("No input files");
     }
 
     // Process files.
     const isBatch = files.length > 1;
-    const promises = files.map((src) => {
-      // Create pipeline.
-      const transformer = queue.drain(sharp(options));
+    const promises = files.map(({ root, src }) => {
+      const image = sharp(context.options);
+      return pipeline(createReadStream(src), image)
+        .then(() => image.metadata())
+        .then((metadata) => {
+          // Process output as a template.
+          const parts = {
+            ...path.parse(src),
+            path: path.relative(root, path.dirname(src)),
+          };
+          const regex = /\{(root|dir|path|base|ext|name)\}/g;
+          let dest = output;
+          let match;
+          while ((match = regex.exec(output)) !== null) {
+            const [search, prop] = match;
+            dest = dest.replace(search, parts[prop]);
+          }
+          dest = path.resolve(dest);
 
-      // Process output as a template.
-      const parts = path.parse(src);
-      const regex = /\{(root|dir|base|ext|name)\}/g;
-      let dest = output;
-      let match;
-      while ((match = regex.exec(output)) !== null) {
-        const [search, prop] = match;
-        dest = dest.replace(search, parts[prop]);
-      }
-      dest = path.resolve(dest);
+          // If output was not a template, assume dest is a directory when using
+          // batch processing.
+          const outputAssumeDir = dest === path.resolve(output) && isBatch;
+          const outputIsDir = outputAssumeDir || isDirectory(dest);
+          const format =
+            context.format ??
+            (outputIsDir ? null : FORMATS[path.extname(dest).toLowerCase()]) ??
+            metadata.format;
+          if (outputIsDir) {
+            const defaultExt = path.extname(src);
+            dest = path.format({
+              dir: dest,
+              name: path.basename(src, defaultExt),
+              ext: format in EXTENSIONS ? EXTENSIONS[format] : defaultExt,
+            });
+          }
 
-      // If output was not a template, assume dest is a directory when using
-      // batch processing.
-      const outputAssumeDir = dest === path.resolve(output) && isBatch;
-      if (outputAssumeDir || isDirectory.sync(dest)) {
-        const defaultExt = path.extname(src);
-        const desiredExt = transformer.options.formatOut;
-        dest = path.format({
-          dir: dest,
-          name: path.basename(src, defaultExt),
-          ext: desiredExt in EXTENSIONS ? EXTENSIONS[desiredExt] : defaultExt,
-        });
-      }
+          const inputMetadata = { ...metadata, path: src };
+          const transformer = drain(context.queue, image, {
+            format,
+            metadata: inputMetadata,
+          });
 
-      // Write, attach info and return.
-      fs.createReadStream(src).pipe(transformer);
-      return transformer
-        .toFile(dest)
-        .then((info) => Object.assign(info, { src, path: dest }));
+          const promise = context.dry
+            ? transformer
+                .toBuffer({ resolveWithObject: true })
+                .then(({ info }) => info)
+            : mkdir(path.dirname(dest), { recursive: true }).then(() =>
+                transformer.toFile(dest),
+              );
+          return promise.then((info) => ({
+            input: inputMetadata,
+            output: { ...info, path: dest },
+          }));
+        });
     });
-    return Promise.all(promises);
+    return Promise.allSettled(promises);
   },
 
   // Convert a stream.
-  stream: (inStream, outStream, options) => {
-    // Create pipeline.
-    const transformer = queue.drain(sharp(options));
+  stream: async (inStream, outStream, context) => {
+    const image = sharp(context.options);
+    return pipeline(inStream, image)
+      .then(() => image.metadata())
+      .then((metadata) => {
+        const inputMetadata = { ...metadata, path: "stdin" };
+        const transformer = drain(context.queue, image, {
+          format: context.format ?? metadata.format,
+          metadata: inputMetadata,
+        });
+
+        if (context.dry) {
+          return transformer
+            .toBuffer({ resolveWithObject: true })
+            .then(({ info }) => ({
+              input: inputMetadata,
+              output: { ...info, path: "stdout" },
+            }));
+        }
 
-    // Gather return value.
-    const info = {};
-    transformer.on("info", (_info) => Object.assign(info, _info));
+        // Gather return value.
+        const info = {};
+        transformer.on("info", (_info) => Object.assign(info, _info));
 
-    // Pipe, and return as promise.
-    return pipeline(inStream, transformer, outStream).then(() => info);
+        return pipeline(transformer, outStream).then(() => ({
+          input: inputMetadata,
+          output: { ...info, path: "stdout" },
+        }));
+      });
   },
 };

package/lib/index.js

@@ -21,33 +21,62 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// Strict mode.
-"use strict";
-
-// Package modules.
-const pick = require("lodash.pick");
-
 // Local modules.
-const cli = require("./cli");
-const convert = require("./convert");
+import cli, { inputOptions } from "./cli.js";
+import convert from "./convert.js";
+import { pick } from "./utils.js";
 
 // Exports.
-module.exports = (args, options = {}) => {
+export default (args, options = {}) => {
   const logger = options.logger || console; // Cast.
 
   // Parse arguments and handle i/o.
   return cli
-    .parse(args)
+    .parseAsync(args)
     .then((argv) => {
-      const options = pick(argv, cli.inputOptions);
+      const context = {
+        dry: argv.dry,
+        format: argv.format,
+        options: pick(argv, Object.keys(inputOptions)),
+        queue: argv["#queue"],
+      };
       if (argv.input) {
-        return convert.files(argv.input, argv.output, options);
+        return convert
+          .files(argv.input, argv.output, context)
+          .then((results) => {
+            // On error, set the code and let the program finish naturally
+            const containsError = results.some(
+              ({ status }) => status === "rejected",
+            );
+            if (containsError) process.exitCode = 1;
+
+            if (argv.print) {
+              const output = results.map(({ reason, status, value }) => {
+                return status === "fulfilled"
+                  ? value
+                  : { error: reason.message };
+              });
+              logger.log(JSON.stringify(output));
+            } else {
+              results.forEach((result) => {
+                if (result.status === "fulfilled") {
+                  logger.log(result.value.output.path);
+                } else {
+                  logger.error(`FAILED: ${result.reason.message}`);
+                }
+              });
+              if (containsError) {
+                logger.error();
+                logger.error("Specify --help for available options");
+              }
+            }
+          });
       }
-      return convert.stream(process.stdin, process.stdout, options);
-    })
-    .then((output) => {
-      const info = Array.isArray(output) ? output : [output];
-      info.forEach((file) => logger.log(file.path));
+      return convert
+        .stream(process.stdin, process.stdout, context)
+        .then((output) => {
+          if (argv.print) logger.log(JSON.stringify(output));
+        });
     })
     .catch((err) => {
       if (err instanceof Error) {

package/lib/utils.js

@@ -0,0 +1,50 @@
+/*!
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Mark van Seventer
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// Standard lib.
+import fs from "node:fs";
+
+const drain = (queue, transformer, context) => {
+  return queue.reduce((pipeline, [, handler]) => {
+    return handler(pipeline, context);
+  }, transformer);
+};
+
+const isDirectory = (path) => {
+  try {
+    return fs.statSync(path).isDirectory();
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+};
+
+const pick = (object, keys) => {
+  return keys.reduce((result, key) => {
+    if (Object.hasOwn(object, key)) result[key] = object[key];
+    return result;
+  }, {});
+};
+
+// Exports.
+export { drain, isDirectory, pick };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/sharp-cli",
-  "version": "5.3.0-depup.0",
+  "version": "6.1.0-depup.0",
   "description": "CLI for sharp. (with updated dependencies)",
   "keywords": [
     "sharp-cli",
@@ -20,64 +20,62 @@
   "homepage": "https://github.com/vseventer/sharp-cli",
   "bugs": "https://github.com/vseventer/sharp-cli/issues",
   "license": "MIT",
+  "type": "module",
   "author": "Mark van Seventer <mark@vseventer.com>",
-  "repository": "vseventer/sharp-cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vseventer/sharp-cli.git"
+  },
   "bin": {
     "sharp": "bin/cli.js"
   },
-  "main": "lib/",
+  "main": "lib/index.js",
   "scripts": {
     "format": "prettier . --write",
-    "pretest": "prettier . --check",
-    "test": "nyc mocha",
+    "lint": "eslint",
+    "pretest": "npm run lint && prettier . --check",
+    "test": "NODE_OPTIONS=--experimental-loader=@istanbuljs/esm-loader-hook nyc mocha",
     "posttest": "nyc report --reporter=lcov"
   },
   "dependencies": {
     "glob": "^13.0.6",
-    "is-directory": "^0.3.1",
-    "lodash.pick": "^4.4.0",
-    "sharp": "^0.35.3",
+    "sharp": "0.35.4",
     "yargs": "^18.1.0"
   },
   "devDependencies": {
-    "fs-extra": "11.3.x",
-    "mocha": "10.8.x",
-    "must": "0.13.x",
-    "nyc": "17.1.x",
-    "prettier": "3.9.6",
-    "sinon": "21.0.x",
-    "tempy": "1.0.x"
+    "@eslint/js": "9.39.x",
+    "@istanbuljs/esm-loader-hook": "0.3.x",
+    "eslint": "9.39.x",
+    "fs-extra": "11.4.x",
+    "globals": "17.11.x",
+    "mocha": "11.8.x",
+    "nyc": "18.0.x",
+    "prettier": "3.9.x",
+    "sinon": "22.1.x",
+    "tempy": "3.2.x"
+  },
+  "overrides": {
+    "diff": "8.0.3",
+    "serialize-javascript": "7.1.1"
   },
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20.10.0"
   },
   "depup": {
     "changes": {
       "glob": {
-        "from": "10.5.x",
+        "from": "13.0.x",
         "to": "^13.0.6"
       },
-      "is-directory": {
-        "from": "0.3.x",
-        "to": "^0.3.1"
-      },
-      "lodash.pick": {
-        "from": "3.1.0",
-        "to": "^4.4.0"
-      },
-      "sharp": {
-        "from": "0.34.5",
-        "to": "^0.35.3"
-      },
       "yargs": {
-        "from": "^17.6.2",
+        "from": "17.7.x",
         "to": "^18.1.0"
       }
     },
-    "depsUpdated": 5,
+    "depsUpdated": 2,
     "originalPackage": "sharp-cli",
-    "originalVersion": "5.3.0",
-    "processedAt": "2026-08-16T00:30:13.494Z",
-    "smokeTest": "failed"
+    "originalVersion": "6.1.0",
+    "processedAt": "2026-09-06T01:03:50.312Z",
+    "smokeTest": "passed"
   }
 }