lint-staged 16.2.6 → 16.3.0

package/README.md

@@ -34,6 +34,10 @@ $ git commit
 
 </details>
 
+> [!Tip]
+> Do you only want to check staged files for errors, but not edit them automatically?  
+> You might be interested in this simpler shell script: [`lint-staged.sh`](https://github.com/lint-staged/lint-staged.sh).
+
 ## Table of Contents
 
 - [Why](#why)

package/lib/colors.js

@@ -2,14 +2,14 @@ import nodeTty from 'node:tty'
 
 /**
  * @example NO_COLOR
- * @exmaple NO_COLOR=1
- * @exmaple NO_COLOR=true
+ * @example NO_COLOR=1
+ * @example NO_COLOR=true
  */
 const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
 
 /**
- * @exmaple FORCE_COLOR=0
- * @exmaple FORCE_COLOR=false
+ * @example FORCE_COLOR=0
+ * @example FORCE_COLOR=false
  */
 const FALSY_ENV_VAR_VALUES = ['0', 'false']
 

package/lib/execGit.js

@@ -1,4 +1,4 @@
-import spawn, { SubprocessError } from 'nano-spawn'
+import { exec } from 'tinyexec'
 
 import { createDebug } from './debug.js'
 
@@ -13,22 +13,25 @@ const NO_SUBMODULE_RECURSE = ['-c', 'submodule.recurse=false']
 // exported for tests
 export const GIT_GLOBAL_OPTIONS = [...NO_SUBMODULE_RECURSE]
 
-/** @type {(cmd: string[], options?: import('nano-spawn').Options) => Promise<string>} */
+/** @type {(cmd: string[], options?: { cwd?: string }) => Promise<string>} */
 export const execGit = async (cmd, options) => {
-  debugLog('Running git command', cmd)
-  try {
-    const result = await spawn('git', [...NO_SUBMODULE_RECURSE, ...cmd], {
-      ...options,
-      cwd: options?.cwd ?? process.cwd(),
-      stdin: 'ignore',
-    })
-
-    return result.stdout
-  } catch (error) {
-    if (error instanceof SubprocessError) {
-      throw new Error(error.output, { cause: error })
-    }
-
-    throw error
+  debugLog('Running git command:', cmd)
+  const result = exec('git', [...NO_SUBMODULE_RECURSE, ...cmd], {
+    nodeOptions: {
+      cwd: options?.cwd,
+      stdio: ['ignore'],
+    },
+  })
+
+  let output = ''
+  for await (const line of result) {
+    output += line + '\n'
+  }
+  output = output.trimEnd()
+
+  if (result.exitCode > 0) {
+    throw new Error(output, { cause: result })
   }
+
+  return output
 }

package/lib/getAbortController.js

@@ -0,0 +1,18 @@
+export const Signal = {
+  SIGINT: 'SIGINT',
+  SIGKILL: 'SIGKILL',
+}
+
+/**
+ * Get an AbortController used to cancel running tasks on failure/interruption.
+ * @returns AbortController
+ */
+export const getAbortController = (nodeProcess = process) => {
+  const abortController = new AbortController()
+
+  nodeProcess.on(Signal.SIGINT, () => {
+    abortController.abort(Signal.SIGINT)
+  })
+
+  return abortController
+}

package/lib/getFunctionTask.js

@@ -1,5 +1,5 @@
 import { createDebug } from './debug.js'
-import { makeErr } from './getSpawnedTask.js'
+import { createTaskError } from './getSpawnedTask.js'
 
 const debugLog = createDebug('lint-staged:getFunctionTasks')
 
@@ -24,7 +24,7 @@ export const getFunctionTask = async (command, files) => {
     try {
       await command.task(files.map((file) => file.filepath))
     } catch (e) {
-      throw makeErr(command.title, e, ctx)
+      throw createTaskError(command.title, e, ctx)
     }
   }
 

package/lib/getSpawnedTask.js

@@ -1,106 +1,42 @@
-import spawn, { SubprocessError } from 'nano-spawn'
-import pidtree from 'pidtree'
 import { parseArgsStringToArgv } from 'string-argv'
+import { exec } from 'tinyexec'
 
 import { blackBright, red } from './colors.js'
 import { createDebug } from './debug.js'
 import { error, info } from './figures.js'
+import { Signal } from './getAbortController.js'
+import { killSubProcesses } from './killSubprocesses.js'
 import { getInitialState } from './state.js'
 import { TaskError } from './symbols.js'
 
-const TASK_ERROR = 'lint-staged:taskError'
-
 const debugLog = createDebug('lint-staged:getSpawnedTask')
 
-/** @type {(error: import('nano-spawn').SubprocessError) => string} */
-const getTag = (error) => {
-  return error.signalName ?? 'FAILED'
-}
-
 /**
  * Handle task console output.
  *
  * @param {string} command
- * @param {import('nano-spawn').Result | import('nano-spawn').SubprocessError} result
- * @param {Object} ctx
- * @returns {Error}
+ * @param {string} output
+ * @param {ReturnType<typeof getInitialState>} ctx context
+ * @param {keyof typeof Signal | undefined} signal
+ * @param {import('tinyexec').Result} [errorResult]
  */
-const handleOutput = (command, result, ctx, isError = false) => {
-  if (result.output) {
-    const outputTitle = isError ? red(`${error} ${command}:`) : `${info} ${command}:`
-    const output = [...(ctx.quiet ? [] : ['', outputTitle]), result.output]
-    ctx.output.push(output.join('\n'))
+const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
+  if (output) {
+    const outputTitle = errorResult ? red(`${error} ${command}:`) : `${info} ${command}:`
+    ctx.output.push([...(ctx.quiet ? [] : ['', outputTitle]), output].join('\n'))
+    return
   }
 
-  if (ctx.quiet) return
-
-  if (result instanceof SubprocessError) {
-    ctx.output.push(red(`\n${error} ${command} failed to spawn:`), result.message, result.cause)
-  } else if (isError) {
-    // Show generic error when task had no output
-    const tag = getTag(result)
-    const message = red(`\n${error} ${command} failed without output (${tag}).`)
-    ctx.output.push(message)
+  if (ctx.quiet) {
+    return
   }
-}
 
-/**
- * Kill subprocess along with all its child processes.
- * @param {import('nano-spawn').Subprocess} subprocess
- */
-const killSubprocess = async (subprocess) => {
-  let childProcess
-
-  try {
-    childProcess = await subprocess.nodeChildProcess
-  } catch {
-    /** ignore internal nano-spawn errors, if child process isn't available it can't be killed */
-  }
-
-  if (childProcess?.pid !== undefined) {
-    try {
-      for (const childPid of await pidtree(childProcess.pid)) {
-        try {
-          process.kill(childPid, 'SIGKILL')
-        } catch (error) {
-          debugLog(`Failed to kill process with pid "%d": %o`, childPid, error)
-        }
-      }
-    } catch (error) {
-      // Suppress "No matching pid found" error. This probably means
-      // the process already died before executing.
-      debugLog(`Failed to list child processes of pid "%d": %o`, childProcess.pid, error)
-    }
-  }
-
-  // The child process is terminated separately in order to get the `KILLED` status.
-  childProcess?.kill('SIGKILL')
-}
-
-/**
- * Interrupts the execution of the subprocess that we spawned if
- * another task adds an error to the context.
- *
- * @param {Object} ctx
- * @param {import('nano-spawn').Subprocess} subprocess
- * @returns {() => Promise<void>} Function that clears the interval that
- * checks the context.
- */
-const interruptExecutionOnError = (ctx, subprocess) => {
-  let killPromise
-
-  const errorListener = async () => {
-    killPromise = killSubprocess(subprocess)
-    await killPromise
-  }
-
-  ctx.events.on(TASK_ERROR, errorListener, { once: true })
-
-  return async () => {
-    ctx.events.off(TASK_ERROR, errorListener)
-    if (killPromise) {
-      await killPromise
-    }
+  if (signal === 'SIGINT') {
+    ctx.output.push(red(`\n${error} Task interrupted: ${command}`))
+  } else if (signal === 'SIGKILL') {
+    ctx.output.push(red(`\n${error} Task killed: ${command}`))
+  } else if (errorResult) {
+    ctx.output.push(red(`\n${error} Task failed to spawn: ${command}`), signal)
   }
 }
 
@@ -108,25 +44,21 @@ const interruptExecutionOnError = (ctx, subprocess) => {
  * Create a error output depending on process result.
  *
  * @param {string} command
- * @param {import('nano-spawn').SubprocessError} error
- * @param {Object} ctx
+ * @param {import('tinyexec').Result} result
+ * @param {ReturnType<typeof getInitialState>} ctx context
+ * @param {keyof typeof Signal | undefined} signal
  * @returns {Error}
  */
-export const makeErr = (command, error, ctx) => {
+export const createTaskError = (command, result, ctx, signal = 'FAILED') => {
   ctx.errors.add(TaskError)
-
-  // https://nodejs.org/api/events.html#error-events
-  ctx.events.emit(TASK_ERROR, TaskError)
-
-  handleOutput(command, error, ctx, true)
-  const tag = getTag(error)
-  return new Error(`${red(command)} ${blackBright(`[${tag}]`)}`)
+  return new Error(`${red(command)} ${blackBright(`[${signal}]`)}`, { cause: result })
 }
 
 /**
  * Returns the task function for the linter.
  *
  * @param {Object} options
+ * @param {AbortController} options.abortController
  * @param {boolean} [options.color]
  * @param {string} options.command — Linter task
  * @param {string} [options.continueOnError]
@@ -138,6 +70,7 @@ export const makeErr = (command, error, ctx) => {
  * @returns {() => Promise<Array<string>>}
  */
 export const getSpawnedTask = ({
+  abortController,
   color,
   command,
   continueOnError = false,
@@ -151,35 +84,78 @@ export const getSpawnedTask = ({
   debugLog('cmd:', cmd)
   debugLog('args:', args)
 
-  const spawnOptions = {
-    // Only use topLevelDir as CWD if we are using the git binary
-    // e.g `npm` should run tasks in the actual CWD
-    cwd: /^git(\.exe)?/i.test(cmd) ? topLevelDir : cwd,
-    preferLocal: true,
-    stdin: 'ignore',
-    env: color ? { FORCE_COLOR: 'true' } : { NO_COLOR: 'true' },
+  /** @type {import('tinyexec').Options}*/
+  const tinyExecOptions = {
+    nodeOptions: {
+      // Only use topLevelDir as CWD if we are using the git binary
+      // e.g `npm` should run tasks in the actual CWD
+      cwd: /^git(\.exe)?/i.test(cmd) ? topLevelDir : cwd,
+      detached: true,
+      env: color ? { FORCE_COLOR: 'true' } : { NO_COLOR: 'true' },
+      stdio: ['ignore'],
+    },
   }
 
-  debugLog('Spawn options:', spawnOptions)
+  debugLog('Tinyexec options:', tinyExecOptions)
 
+  /** @param {ReturnType<typeof getInitialState>} ctx context */
   return async (ctx = getInitialState()) => {
-    let quitInterruptCheck
+    const result = exec(cmd, isFn ? args : args.concat(files), tinyExecOptions)
 
+    const taskFailed = () => result.exitCode > 0 || result.process?.signalCode
+
+    /** @type {keyof typeof Signal | undefined} */
+    let signal
+
+    abortController.signal.addEventListener(
+      'abort',
+      async () => {
+        if (taskFailed() || !result.process) return
+
+        signal = abortController.signal.reason
+        const pid = result.process.pid
+        result.process.kill(abortController.signal.reason)
+        await killSubProcesses(pid)
+      },
+      { once: true }
+    )
+
+    let output = ''
     try {
-      const subprocess = spawn(cmd, isFn ? args : args.concat(files), spawnOptions)
-      if (!continueOnError) {
-        quitInterruptCheck = interruptExecutionOnError(ctx, subprocess)
-      }
-      const result = await subprocess
-      if (verbose) {
-        handleOutput(command, result, ctx)
+      for await (const line of result) {
+        output += line + '\n'
       }
     } catch (error) {
-      throw makeErr(command, error, ctx)
-    } finally {
-      if (quitInterruptCheck) {
-        await quitInterruptCheck()
+      /** Probably failed to spawn (ENOENT) */
+      const errorSignal = (error instanceof Error && error.code) || 'FAILED'
+
+      if (continueOnError !== true) {
+        /** Other tasks should be killed */
+        abortController.abort(Signal.SIGKILL)
+      }
+
+      handleTaskOutput(command, output, ctx, errorSignal, result)
+      throw createTaskError(command, result, ctx, errorSignal)
+    }
+
+    output = output.trimEnd()
+
+    if (taskFailed()) {
+      if (continueOnError !== true) {
+        /** Other tasks should be killed */
+        abortController.abort(Signal.SIGKILL)
       }
+
+      if (result.process?.pid) {
+        await killSubProcesses(result.process.pid)
+      }
+
+      handleTaskOutput(command, output, ctx, signal, result)
+      throw createTaskError(command, result, ctx, result.process?.signalCode ?? signal)
+    }
+
+    if (verbose) {
+      handleTaskOutput(command, output, ctx, signal)
     }
   }
 }

package/lib/getSpawnedTasks.js

@@ -8,6 +8,7 @@ const debugLog = createDebug('lint-staged:getSpawnedTasks')
  * Creates and returns an array of listr tasks which map to the given commands.
  *
  * @param {object} options
+ * @param {AbortController} options.abortController
  * @param {boolean} [options.color]
  * @param {Array<string|Function>|string|Function} options.commands
  * @param {string} options.continueOnError
@@ -17,6 +18,7 @@ const debugLog = createDebug('lint-staged:getSpawnedTasks')
  * @param {Boolean} verbose
  */
 export const getSpawnedTasks = async ({
+  abortController,
   color,
   commands,
   continueOnError,
@@ -55,6 +57,7 @@ export const getSpawnedTasks = async ({
       }
 
       const task = getSpawnedTask({
+        abortController,
         color,
         command,
         continueOnError,

package/lib/killSubprocesses.js

@@ -0,0 +1,42 @@
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(exec)
+
+/**
+ * End process by pid, forcefully, including child processes
+ *
+ * @see {@link https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill}
+ *
+ * @param {number} pid
+ */
+const killWin32Subprocesses = async (pid) => {
+  await execAsync(`taskkill /pid ${pid} /T /F`)
+}
+
+/**
+ * Kill all processes in the group by using negative pid
+ *
+ * @see {@link https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html}
+ *
+ * @param {number} pid
+ */
+const killUnixSubprocesses = async (pid) => {
+  process.kill(-pid, 'SIGKILL')
+}
+
+/**
+ * @param {number} pid
+ * @param {boolean} [isWin32]
+ */
+export const killSubProcesses = async (pid, isWin32 = process.platform === 'win32') => {
+  try {
+    if (isWin32) {
+      await killWin32Subprocesses(pid)
+    } else {
+      await killUnixSubprocesses(pid)
+    }
+  } catch {
+    /** ignore errors */
+  }
+}

package/lib/runAll.js

@@ -9,6 +9,7 @@ import { blackBright } from './colors.js'
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
+import { getAbortController } from './getAbortController.js'
 import { getFunctionTask, isFunctionTask } from './getFunctionTask.js'
 import { getRenderer } from './getRenderer.js'
 import { getSpawnedTasks } from './getSpawnedTasks.js'
@@ -187,20 +188,14 @@ export const runAll = async (
     ...getRenderer({ color, debug, quiet }, logger),
   }
 
-  /**
-   * This is used to set max event listener count to the total number
-   * of generated tasks. The event listener is used to keep track of
-   * the interrupt signal and kill all tasks when it happens. See the
-   * `interruptExecutionOnError` in `getSpawnedTask`.
-   */
-  let listrTaskCount = 0
-
   const listrTasks = []
 
   // Set of all staged files that matched a task glob. Values in a set are unique.
   /** @type {Set<import('./getStagedFiles.js').StagedFile>} */
   const matchedFiles = new Set()
 
+  const abortController = getAbortController()
+
   for (const [configPath, { config, files }] of Object.entries(filesByConfig)) {
     const configName = configPath ? normalizePath(path.relative(cwd, configPath)) : 'Config object'
 
@@ -222,6 +217,7 @@ export const runAll = async (
           (isFunctionTask(task.commands)
             ? getFunctionTask(task.commands, task.fileList)
             : getSpawnedTasks({
+                abortController,
                 color,
                 commands: task.commands,
                 continueOnError,
@@ -273,8 +269,6 @@ export const runAll = async (
         )
       )
 
-      listrTaskCount += chunkListrTasks.length
-
       listrTasks.push({
         title:
           `${configName}${blackBright(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
@@ -368,9 +362,6 @@ export const runAll = async (
     listrOptions
   )
 
-  debugLog('Set max event listeners to the number of tasks: %i', listrTaskCount)
-  ctx.events.setMaxListeners(listrTaskCount)
-
   await runner.run()
 
   if (ctx.errors.size > 0) {

package/lib/state.js

@@ -1,5 +1,3 @@
-import EventEmitter from 'events'
-
 import { GIT_ERROR, TASK_ERROR } from './messages.js'
 import {
   FailOnChangesError,
@@ -18,7 +16,6 @@ export const getInitialState = ({
 } = {}) => ({
   backupHash: null,
   errors: new Set([]),
-  events: new EventEmitter(),
   shouldFailOnChanges: failOnChanges,
   hasFilesToHide: null,
   output: [],

package/lib/validateBraces.js

@@ -28,7 +28,8 @@ import { incorrectBraces } from './messages.js'
  * - *.${js}      // dollar-sign inhibits expansion, so treated literally
  * - *.{js\,ts}   // the comma is escaped, so treated literally
  */
-export const INCORRECT_BRACES_REGEXP = /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g
+export const getIncorrectBracesRegexp = () =>
+  /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g
 
 /**
  * @param {string} pattern
@@ -36,12 +37,15 @@ export const INCORRECT_BRACES_REGEXP = /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).
  */
 const stripIncorrectBraces = (pattern) => {
   let output = `${pattern}`
-  let match = null
+  const regexp = getIncorrectBracesRegexp()
+  let match = regexp.exec(output)
 
-  while ((match = INCORRECT_BRACES_REGEXP.exec(pattern))) {
+  while (match) {
     const fullMatch = match[0]
     const withoutBraces = fullMatch.replace(/{/, '').replace(/}/, '')
     output = output.replace(fullMatch, withoutBraces)
+    regexp.lastIndex = 0 // restart iteration
+    match = regexp.exec(output)
   }
 
   return output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "16.2.6",
+  "version": "16.3.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {
@@ -48,35 +48,35 @@
     "tag": "npx changeset tag"
   },
   "dependencies": {
-    "commander": "^14.0.1",
+    "commander": "^14.0.3",
     "listr2": "^9.0.5",
     "micromatch": "^4.0.8",
     "nano-spawn": "^2.0.0",
-    "pidtree": "^0.6.0",
     "string-argv": "^0.3.2",
-    "yaml": "^2.8.1"
+    "tinyexec": "^1.0.2",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "0.5.1",
-    "@changesets/cli": "2.29.7",
-    "@commitlint/cli": "20.1.0",
-    "@commitlint/config-conventional": "20.0.0",
-    "@eslint/js": "9.38.0",
-    "@vitest/coverage-v8": "4.0.1",
-    "@vitest/eslint-plugin": "1.3.23",
+    "@changesets/changelog-github": "0.5.2",
+    "@changesets/cli": "2.29.8",
+    "@commitlint/cli": "20.4.2",
+    "@commitlint/config-conventional": "20.4.2",
+    "@eslint/js": "10.0.1",
+    "@vitest/coverage-v8": "4.0.18",
+    "@vitest/eslint-plugin": "1.6.9",
     "consolemock": "1.1.0",
     "cross-env": "10.1.0",
-    "eslint": "9.38.0",
+    "eslint": "10.0.2",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-n": "17.23.1",
-    "eslint-plugin-prettier": "5.5.4",
+    "eslint-plugin-n": "17.24.0",
+    "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-simple-import-sort": "12.1.1",
     "husky": "9.1.7",
     "mock-stdin": "1.0.0",
-    "prettier": "3.6.2",
-    "semver": "7.7.3",
+    "prettier": "3.8.1",
+    "semver": "7.7.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.1"
+    "vitest": "4.0.18"
   },
   "keywords": [
     "lint",