image-guard 5.4.0 → 5.4.2

package/README.md

@@ -158,11 +158,24 @@ Image Guard is no substitute for image fine-tuning and micro-optimization. That
 
 That is, micro-optimization still needs to be taken care of through other means, whether manually or through tools. Image Guard just solves the problem that images are checked in or go live that are not compressed _at all_.
 
-## What’s Next?
+## Working on Image Guard
 
-There are a few ideas, like adding light SVG support, or ensuring compatibility with projects in which the project’s .git folder is not at the same level as its package.json (currently, automatic mode doesn’t work in these cases).
+### Benchmarking
 
-Feedback is appreciated: Please [file an issue](https://github.com/j9t/image-guard/issues/new) or send a pull request. Thank you!
+To check how a change affects speed, memory, and compression, run the benchmark on any local folder with images:
+
+```shell
+npm run benchmark -- ~/Projects
+```
+
+The benchmark copies a deterministic sample of the images (honoring .gitignore) to a temporary folder, runs Image Guard on fresh copies of it several times, and reports the median time, peak memory, and bytes saved. Your images are not modified.
+
+* `--runs <n>` sets the number of runs (default: 3).
+* `--sample <n>` sets the approximate sample size (default: 300). Each format is sampled in proportion to its share, with at least 10 files per format where available.
+* `--save` saves the result as the baseline (benchmark/baseline.json, ignored by Git), which later runs on the same sample compare against.
+* `--profile` additionally compresses each image on its own, in dry mode, and reports the time per format and the slowest files.
+
+To compare a branch with `main`, run the benchmark with `--save` on `main`, then without it on the branch. Differences of around 10% can be noise; use more runs, and repeat a run on `main`, before relying on smaller ones.
 
 ## License
 

package/package.json

@@ -6,16 +6,20 @@
     "imagemin-merlin": "bin/image-guard.sh"
   },
   "dependencies": {
-    "globby": "^16.2.3",
     "heic-decode": "^2.1.0",
-    "sharp": "^0.35.3",
-    "simple-git": "^3.36.0"
+    "ignore": "^7.0.12",
+    "sharp": "^0.35.5",
+    "simple-git": "^4.0.2",
+    "tinyglobby": "^0.2.17"
   },
   "description": "Near-lossless image compressor that’s easy to use and easy to automate",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.8.1",
-    "globals": "^17.11.0"
+    "eslint": "^10.12.0",
+    "globals": "^17.13.0"
+  },
+  "engines": {
+    "node": ">=22.13"
   },
   "files": [
     "bin/image-guard.js",
@@ -49,11 +53,12 @@
     "url": "git+https://github.com/j9t/image-guard.git"
   },
   "scripts": {
+    "benchmark": "node benchmark/benchmark.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "prepare": "git config core.hooksPath .githooks || true",
-    "test": "node --test bin/image-guard.test.js"
+    "test": "node --test bin/image-guard.test.js benchmark/benchmark.test.js"
   },
   "type": "module",
-  "version": "5.4.0"
+  "version": "5.4.2"
 }

package/src/gitignore.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import ignore from 'ignore'
+
+function findGitRoot(dir) {
+  for (let current = dir; ; current = path.dirname(current)) {
+    if (fs.existsSync(path.join(current, '.git'))) return current
+    if (path.dirname(current) === current) return undefined
+  }
+}
+
+// Returns a predicate for absolute paths under `cwd` that applies .gitignore
+// files from the repository root (or `cwd` outside a repository) down to each
+// path, as Git does: Deeper rules take precedence, and nothing inside an
+// ignored directory can be re-included
+export function createGitignoreFilter(cwd) {
+  const base = path.resolve(cwd)
+  const top = findGitRoot(base) ?? base
+  const rulesByDir = new Map()
+
+  const getRules = (dir) => {
+    if (!rulesByDir.has(dir)) {
+      let rules
+      try {
+        rules = ignore().add(fs.readFileSync(path.join(dir, '.gitignore'), 'utf8'))
+      } catch (err) {
+        if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+      }
+      rulesByDir.set(dir, rules)
+    }
+    return rulesByDir.get(dir)
+  }
+
+  return (file) => {
+    const segments = path.relative(top, file).split(path.sep)
+    for (let i = 1; i <= segments.length; i++) {
+      const suffix = i < segments.length ? '/' : ''
+      let ignored = false
+      for (let j = 0; j < i; j++) {
+        const rules = getRules(path.join(top, ...segments.slice(0, j)))
+        if (!rules) continue
+        const result = rules.test(segments.slice(j, i).join('/') + suffix)
+        if (result.ignored) ignored = true
+        else if (result.unignored) ignored = false
+      }
+      if (ignored) return true
+    }
+    return false
+  }
+}

package/src/index.js

@@ -1,12 +1,13 @@
 // This file, which had been forked from imagemin-merlin, was modified for image-guard: https://github.com/sumcumo/imagemin-merlin/compare/master...j9t:master
 
-import { globby, convertPathToPattern } from 'globby'
-import simpleGit from 'simple-git'
+import { glob, convertPathToPattern } from 'tinyglobby'
+import { simpleGit } from 'simple-git'
 import { parseArgs, styleText } from 'node:util'
 import fsSync from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import sharp from 'sharp'
+import { createGitignoreFilter } from './gitignore.js'
 import { styleStderr, utils } from './utils.js'
 
 // Files to be compressed
@@ -147,8 +148,14 @@ Options:
     })
   }
 
-  const desiredFileConcurrency = Math.min(os.cpus().length, 4)
-  const perTaskThreads = Math.max(1, Math.floor(os.cpus().length / Math.max(1, desiredFileConcurrency)))
+  // Capped to bound memory, as each file in flight holds its decoded pixels
+  const desiredFileConcurrency = Math.min(os.availableParallelism(), 8)
+  const perTaskThreads = Math.max(1, Math.floor(os.availableParallelism() / desiredFileConcurrency))
+
+  // sharp runs on libuv’s thread pool (4 threads by default), which caps files
+  // in flight regardless of the limiter; this must happen before the first
+  // asynchronous I/O and respects a user setting
+  process.env.UV_THREADPOOL_SIZE ??= String(desiredFileConcurrency)
   try {
     sharp.concurrency(perTaskThreads)
   } catch {
@@ -194,7 +201,7 @@ Options:
   }
 
   // Plain patterns also get a “/**” variant so directories are excluded with
-  // their contents: “dir/” resolves only where globby can stat it, and a bare
+  // their contents: “dir/” resolves only where tinyglobby can stat it, and a bare
   // “dir” only covers what the walk descends into
   const getIgnorePatterns = (ignore) => {
     return (ignore || '')
@@ -223,14 +230,14 @@ Options:
   // lookup are relative to the searched directory, not to the shell’s—and the
   // results are rejoined for display and file access
   const findFiles = async (patterns, options = {}) => {
-    const files = await globby(patterns, {
+    const files = await glob(patterns, {
       cwd: dir,
-      gitignore: true,
       onlyFiles: true,
       caseSensitiveMatch: false,
       ...options
     })
-    return files.map(file => path.join(dir, file))
+    const isGitignored = createGitignoreFilter(dir)
+    return files.map(file => path.join(dir, file)).filter(file => !isGitignored(path.resolve(file)))
   }
 
   const filterStagedFiles = async (stagedFiles, types) => {
@@ -240,12 +247,13 @@ Options:
 
     if (ignoreList.length > 0) {
       const escapedPaths = byExt.map(p => convertPathToPattern(p))
-      return globby([...escapedPaths, ...ignoreList], {
-        gitignore: true,
+      const files = await glob([...escapedPaths, ...ignoreList], {
         expandDirectories: false,
         onlyFiles: true,
         caseSensitiveMatch: false
       })
+      const isGitignored = createGitignoreFilter('.')
+      return files.filter(file => !isGitignored(path.resolve(file)))
     }
     return byExt
   }