lint-staged 16.1.6 → 16.2.1

package/README.md

@@ -112,43 +112,101 @@ Options:
   --diff [string]                    override the default "--staged" flag of "git diff" to get list of files. Implies
                                      "--no-stash".
   --diff-filter [string]             override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
+  --continue-on-error                run all tasks to completion even if one fails (default: false)
+  --fail-on-changes                  fail with exit code 1 when tasks modify tracked files (default: false)
   --max-arg-length [number]          maximum length of the command-line argument string (default: 0)
   --no-revert                        do not revert to original state in case of errors.
   --no-stash                         disable the backup stash. Implies "--no-revert".
   --no-hide-partially-staged         disable hiding unstaged changes from partially staged files
+  --hide-unstaged                    hide all unstaged changes, instead of just partially staged (default: false)
   -q, --quiet                        disable lint-staged’s own console output (default: false)
   -r, --relative                     pass relative filepaths to tasks (default: false)
-  -v, --verbose                      show task output even when tasks succeed; by default only failed output is
-                                     shown (default: false)
+  -v, --verbose                      show task output even when tasks succeed; by default only failed output is shown
+                                     (default: false)
   -h, --help                         display help for command
 
 Any lost modifications can be restored from a git stash:
 
-  > git stash list
-  stash@{0}: automatic lint-staged backup
-  > git stash apply --index stash@{0}
+  > git stash list --format="%h %s"
+  h0a0s0h0 On main: lint-staged automatic backup
+  > git apply --index h0a0s0h0
 ```
 
-- **`--allow-empty`**: By default, when tasks undo all staged changes, lint-staged will exit with an error and abort the commit. Use this flag to allow creating empty git commits.
-- **`--concurrent [number|boolean]`**: Controls the [concurrency of tasks](#task-concurrency) being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
-  - `false`: Run all tasks serially
-  - `true` (default) : _Infinite_ concurrency. Runs as many tasks in parallel as possible.
-  - `{number}`: Run the specified number of tasks in parallel, where `1` is equivalent to `false`.
-- **`--config [path]`**: Manually specify a path to a config file or npm package name. Note: when used, lint-staged won't perform the config file search and will print an error if the specified file cannot be found. If '-' is provided as the filename then the config will be read from stdin, allowing piping in the config like `cat my-config.json | npx lint-staged --config -`.
-- **`--cwd [path]`**: By default tasks run in the current working directory. Use the `--cwd some/directory` to override this. The path can be absolute or relative to the current working directory.
-- **`--debug`**: Run in debug mode. When set, it does the following:
-  - uses [debug](https://github.com/visionmedia/debug) internally to log additional information about staged files, commands being executed, location of binaries, etc. Debug logs, which are automatically enabled by passing the flag, can also be enabled by setting the environment variable `$DEBUG` to `lint-staged*`.
-  - uses [`verbose` renderer](https://listr2.kilic.dev/renderers/verbose-renderer/) for `listr2`; this causes serial, uncoloured output to the terminal, instead of the default (beautified, dynamic) output.
-    (the [`verbose` renderer](https://listr2.kilic.dev/renderers/verbose-renderer/) can also be activated by setting the `TERM=dumb` or `NODE_ENV=test` environment variables)
-- **`--diff`**: By default tasks are filtered against all files staged in git, generated from `git diff --staged`. This option allows you to override the `--staged` flag with arbitrary revisions. For example to get a list of changed files between two branches, use `--diff="branch1...branch2"`. You can also read more from about [git diff](https://git-scm.com/docs/git-diff) and [gitrevisions](https://git-scm.com/docs/gitrevisions). This option also implies `--no-stash`.
-- **`--diff-filter`**: By default only files that are _added_, _copied_, _modified_, or _renamed_ are included. Use this flag to override the default `ACMR` value with something else: _added_ (`A`), _copied_ (`C`), _deleted_ (`D`), _modified_ (`M`), _renamed_ (`R`), _type changed_ (`T`), _unmerged_ (`U`), _unknown_ (`X`), or _pairing broken_ (`B`). See also the `git diff` docs for [--diff-filter](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203).
-- **`--max-arg-length`**: long commands (a lot of files) are automatically split into multiple chunks when it detects the current shell cannot handle them. Use this flag to override the maximum length of the generated command string.
-- **`--no-stash`**: By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit.
-- **`--no-hide-partially-staged`**: By default, unstaged changes from partially staged files will be hidden and applied back after running tasks. This option will disable this behavior, causing those changes to also be committed.
-- **`--quiet`**: Suppress all CLI output, except from tasks.
-- **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
-- **`--no-revert`**: By default all task modifications will be reverted in case of an error. This option will disable the behavior, and apply task modifications to the index before aborting the commit.
-- **`--verbose`**: Show task output even when tasks succeed. By default only failed output is shown.
+#### `--allow-empty`
+
+By default, when tasks undo all staged changes, lint-staged will exit with an error and abort the commit. Use this flag to allow creating empty git commits.
+
+#### `--concurrent [number|boolean]`
+
+Controls the [concurrency of tasks](#task-concurrency) being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
+
+- `false`: Run all tasks serially
+- `true` (default) : _Infinite_ concurrency. Runs as many tasks in parallel as possible.
+- `{number}`: Run the specified number of tasks in parallel, where `1` is equivalent to `false`.
+
+#### `--config [path]`
+
+Manually specify a path to a config file or npm package name. Note: when used, lint-staged won't perform the config file search and will print an error if the specified file cannot be found. If '-' is provided as the filename then the config will be read from stdin, allowing piping in the config like `cat my-config.json | npx lint-staged --config -`.
+
+#### `--cwd [path]`
+
+By default tasks run in the current working directory. Use the `--cwd some/directory` to override this. The path can be absolute or relative to the current working directory.
+
+#### `--debug`
+
+Run in debug mode. When set, it does the following:
+
+- log additional information about staged files, commands being executed, location of binaries, etc.
+- uses [`verbose` renderer](https://listr2.kilic.dev/renderers/verbose-renderer/) for `listr2`; this causes serial, uncoloured output to the terminal, instead of the default (beautified, dynamic) output.
+  (the [`verbose` renderer](https://listr2.kilic.dev/renderers/verbose-renderer/) can also be activated by setting the `TERM=dumb` or `NODE_ENV=test` environment variables)
+
+#### `--diff`
+
+By default tasks are filtered against all files staged in git, generated from `git diff --staged`. This option allows you to override the `--staged` flag with arbitrary revisions. For example to get a list of changed files between two branches, use `--diff="branch1...branch2"`. You can also read more from about [git diff](https://git-scm.com/docs/git-diff) and [gitrevisions](https://git-scm.com/docs/gitrevisions). This option also implies `--no-stash`.
+
+#### `--diff-filter [string]`
+
+By default only files that are _added_, _copied_, _modified_, or _renamed_ are included. Use this flag to override the default `ACMR` value with something else: _added_ (`A`), _copied_ (`C`), _deleted_ (`D`), _modified_ (`M`), _renamed_ (`R`), _type changed_ (`T`), _unmerged_ (`U`), _unknown_ (`X`), or _pairing broken_ (`B`). See also the `git diff` docs for [--diff-filter](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203).
+
+#### `--continue-on-error`
+
+By default _lint-staged_ will "exit early" when any of the configured tasks fails, to make sure the runtime is short. With this flag, _lint-staged_ will instead run all tasks to completion and only fail at the end, allowing all task output to be seen.
+
+#### `--fail-on-changes`
+
+By default changes made by tasks are automatically staged and added to the commit. This flag disables the behavior and makes _lint-staged_ exit with code 1, failing the commit instead. Using this flag also implies the `--no-revert` flag which means any changes made my tasks will be left in the working tree after failing, so that they can be manually staged and the commit tried again.
+
+#### `--max-arg-length [number]`
+
+long commands (a lot of files) are automatically split into multiple chunks when it detects the current shell cannot handle them. Use this flag to override the maximum length of the generated command string.
+
+#### `--no-stash`
+
+By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit.
+
+#### `--no-hide-partially-staged`
+
+By default, unstaged changes from partially staged files will be hidden and applied back after running tasks. This option will disable this behavior, causing those changes to also be committed.
+
+#### `--hide-unstaged`
+
+Use this option to hide all unstaged changes to tracked files before running tasks. The changes will be applied back after running the tasks. Note that the combination of flags `--hide-unstaged --no-hide-partially-staged` isn't meaningful and behaves the same as just `--hide-unstaged`.
+
+#### `--quiet`
+
+Suppress all CLI output, except from tasks.
+
+#### `--relative`
+
+Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
+
+#### `--no-revert`
+
+By default all task modifications will be reverted in case of an error. This option will disable the behavior, and apply task modifications to the index before aborting the commit.
+
+#### `--verbose`
+
+Show task output even when tasks succeed. By default only failed output is shown.
 
 ## Configuration
 
@@ -912,6 +970,14 @@ You can then run lint-staged against the same files with:
 npx lint-staged --diff="main...my-branch"
 ```
 
+Note that --diff="main..my-branch" will have files that changed on `main` and are not yet caught up on `my-branch` be detected as changed files.
+
+To see just that changes on the current branch, as compared to `main` you may wish to use:
+
+```
+npx lint-staged --diff="$(git merge-base main HEAD)"
+```
+
 </details>
 
 ### Can I use `lint-staged` with `ng lint`

package/bin/lint-staged.js

@@ -2,70 +2,83 @@
 
 import { userInfo } from 'node:os'
 
-import { supportsColor } from 'chalk'
 import { Option, program } from 'commander'
-import debug from 'debug'
 
+import { createDebug, enableDebug } from '../lib/debug.js'
 import lintStaged from '../lib/index.js'
 import { CONFIG_STDIN_ERROR, RESTORE_STASH_EXAMPLE } from '../lib/messages.js'
 import { readStdin } from '../lib/readStdin.js'
 import { getVersion } from '../lib/version.js'
 
-// Force colors for packages that depend on https://www.npmjs.com/package/supports-color
-if (supportsColor) {
-  process.env.FORCE_COLOR = supportsColor.level.toString()
-}
-
-const debugLog = debug('lint-staged:bin')
+const debugLog = createDebug('lint-staged:bin')
 
 // Do not terminate main Listr process on SIGINT
 process.on('SIGINT', () => {})
 
-program.version(await getVersion())
-
-/**
- * This shouldn't be necessary for lint-staged, but add migration step just in case
- * to preserve old behavior of "commander".
- *
- * @todo remove this in the major version
- * @see https://github.com/tj/commander.js/releases/tag/v13.0.0
- * */
-program.allowExcessArguments()
-
-program.option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
-
-program.option(
-  '-p, --concurrent <number|boolean>',
-  'the number of tasks to run concurrently, or false for serial',
-  true
-)
-
-program.option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
-
-program.option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
-
-program.option('-d, --debug', 'print additional debug information', false)
-
-program.addOption(
-  new Option(
-    '--diff [string]',
-    'override the default "--staged" flag of "git diff" to get list of files. Implies "--no-stash".'
-  ).implies({ stash: false })
-)
+program
+  .version(await getVersion())
 
-program.option(
-  '--diff-filter [string]',
-  'override the default "--diff-filter=ACMR" flag of "git diff" to get list of files'
-)
+  /**
+   * This shouldn't be necessary for lint-staged, but add migration step just in case
+   * to preserve old behavior of "commander".
+   *
+   * @todo remove this in the major version
+   * @see https://github.com/tj/commander.js/releases/tag/v13.0.0
+   * */
+  .allowExcessArguments()
 
-program.option('--max-arg-length [number]', 'maximum length of the command-line argument string', 0)
+  .addOption(
+    new Option('--allow-empty', 'allow empty commits when tasks revert all staged changes').default(
+      false
+    )
+  )
+  .addOption(
+    new Option(
+      '-p, --concurrent <number|boolean>',
+      'the number of tasks to run concurrently, or false for serial'
+    ).default(true)
+  )
+  .addOption(
+    new Option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
+  )
+  .addOption(
+    new Option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
+  )
+  .addOption(new Option('-d, --debug', 'print additional debug information').default(false))
+  .addOption(
+    new Option(
+      '--diff [string]',
+      'override the default "--staged" flag of "git diff" to get list of files. Implies "--no-stash".'
+    ).implies({ stash: false })
+  )
+  .addOption(
+    new Option(
+      '--diff-filter [string]',
+      'override the default "--diff-filter=ACMR" flag of "git diff" to get list of files'
+    )
+  )
+  .addOption(
+    new Option('--continue-on-error', 'run all tasks to completion even if one fails').default(
+      false
+    )
+  )
+  .addOption(
+    new Option('--fail-on-changes', 'fail with exit code 1 when tasks modify tracked files')
+      .default(false)
+      .implies({ revert: false })
+  )
+  .addOption(
+    new Option(
+      '--max-arg-length [number]',
+      'maximum length of the command-line argument string'
+    ).default(0)
+  )
 
-/**
- * We don't want to show the `--revert` flag because it's on by default, and only show the
- * negatable flag `--no-rever` instead. There seems to be a bug in Commander.js where
- * configuring only the latter won't actually set the default value.
- */
-program
+  /**
+   * We don't want to show the `--revert` flag because it's on by default, and only show the
+   * negatable flag `--no-rever` instead. There seems to be a bug in Commander.js where
+   * configuring only the latter won't actually set the default value.
+   */
   .addOption(
     new Option('--revert', 'revert to original state in case of errors').default(true).hideHelp()
   )
@@ -73,7 +86,6 @@ program
     new Option('--no-revert', 'do not revert to original state in case of errors.').default(false)
   )
 
-program
   .addOption(new Option('--stash', 'enable the backup stash').default(true).hideHelp())
   .addOption(
     new Option('--no-stash', 'disable the backup stash. Implies "--no-revert".')
@@ -81,7 +93,6 @@ program
       .implies({ revert: false })
   )
 
-program
   .addOption(
     new Option('--hide-partially-staged', 'hide unstaged changes from partially staged files')
       .default(true)
@@ -94,38 +105,46 @@ program
     ).default(false)
   )
 
-program.option('-q, --quiet', 'disable lint-staged’s own console output', false)
-
-program.option('-r, --relative', 'pass relative filepaths to tasks', false)
+  .addOption(
+    new Option('--hide-unstaged', 'hide all unstaged changes, instead of just partially staged')
+      .default(false)
+      .implies({ hidePartiallyStaged: false })
+  )
 
-program.option(
-  '-v, --verbose',
-  'show task output even when tasks succeed; by default only failed output is shown',
-  false
-)
+  .addOption(new Option('-q, --quiet', 'disable lint-staged’s own console output').default(false))
+  .addOption(new Option('-r, --relative', 'pass relative filepaths to tasks').default(false))
+  .addOption(
+    new Option(
+      '-v, --verbose',
+      'show task output even when tasks succeed; by default only failed output is shown'
+    ).default(false)
+  )
 
-program.addHelpText('afterAll', '\n' + RESTORE_STASH_EXAMPLE)
+  .addHelpText('afterAll', '\n' + RESTORE_STASH_EXAMPLE)
 
 const cliOptions = program.parse(process.argv).opts()
 
 if (cliOptions.debug) {
-  debug.enable('lint-staged*')
+  enableDebug()
 }
 
 const options = {
   allowEmpty: !!cliOptions.allowEmpty,
   concurrent: JSON.parse(cliOptions.concurrent),
   configPath: cliOptions.config,
+  continueOnError: !!cliOptions.continueOnError,
   cwd: cliOptions.cwd,
   debug: !!cliOptions.debug,
   diff: cliOptions.diff,
   diffFilter: cliOptions.diffFilter,
+  failOnChanges: !!cliOptions.failOnChanges,
+  hidePartiallyStaged: !!cliOptions.hidePartiallyStaged, // commander inverts `no-<x>` flags to `!x`
+  hideUnstaged: !!cliOptions.hideUnstaged,
   maxArgLength: cliOptions.maxArgLength || undefined,
   quiet: !!cliOptions.quiet,
   relative: !!cliOptions.relative,
   revert: !!cliOptions.revert, // commander inverts `no-<x>` flags to `!x`
   stash: !!cliOptions.stash, // commander inverts `no-<x>` flags to `!x`
-  hidePartiallyStaged: !!cliOptions.hidePartiallyStaged, // commander inverts `no-<x>` flags to `!x`
   verbose: !!cliOptions.verbose,
 }
 
@@ -150,9 +169,7 @@ if (options.configPath === '-') {
   }
 }
 
-try {
-  const passed = await lintStaged(options)
-  process.exitCode = passed ? 0 : 1
-} catch {
+const passed = await lintStaged(options)
+if (!passed) {
   process.exitCode = 1
 }

package/lib/chunkFiles.js

@@ -1,10 +1,9 @@
 import path from 'node:path'
 
-import debug from 'debug'
-
+import { createDebug } from './debug.js'
 import { normalizePath } from './normalizePath.js'
 
-const debugLog = debug('lint-staged:chunkFiles')
+const debugLog = createDebug('lint-staged:chunkFiles')
 
 /**
  * Chunk array into sub-arrays

package/lib/colors.js

@@ -0,0 +1,106 @@
+import nodeTty from 'node:tty'
+
+/**
+ * @example NO_COLOR
+ * @exmaple NO_COLOR=1
+ * @exmaple NO_COLOR=true
+ */
+const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
+
+/**
+ * @exmaple FORCE_COLOR=0
+ * @exmaple FORCE_COLOR=false
+ */
+const FALSY_ENV_VAR_VALUES = ['0', 'false']
+
+/**
+ * @returns `true` if ANSI colors are supported
+ *
+ * @param {NodeJS.Process} [p]
+ * @param {boolean} [isTty]
+ */
+export const supportsAnsiColors = (p = process, isTty = nodeTty.isatty(1)) => {
+  const noColor = p?.env?.NO_COLOR?.toLowerCase()
+  if (TRUTHRY_ENV_VAR_VALUES.includes(noColor)) {
+    return false
+  }
+
+  const forceColor = p?.env?.FORCE_COLOR?.toLowerCase()
+  if (TRUTHRY_ENV_VAR_VALUES.includes(forceColor)) {
+    return true
+  } else if (FALSY_ENV_VAR_VALUES.includes(forceColor)) {
+    return false
+  }
+
+  const forceTty = p?.env?.FORCE_TTY
+  if (TRUTHRY_ENV_VAR_VALUES.includes(forceTty)) {
+    return true
+  } else if (FALSY_ENV_VAR_VALUES.includes(forceTty)) {
+    return false
+  }
+
+  if (isTty) {
+    return true
+  }
+
+  /**
+   * Assume CI supports color
+   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
+   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L91}
+   */
+  if (TRUTHRY_ENV_VAR_VALUES.includes(p?.env?.CI)) {
+    return true
+  }
+
+  if (p?.env?.TERM && p.env.TERM === 'dumb') {
+    return false
+  }
+
+  /**
+   * Assume Windows supports color
+   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
+   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L89}
+   */
+  if (p?.platform === 'win32') {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
+ * @example util.styleText('red', 'test') !== 'text'
+ */
+export const SUPPORTS_COLOR = supportsAnsiColors()
+
+const ANSI_RESET = '\u001B[0m'
+
+/**
+ * @callback WrapAnsi
+ * @param {string} text
+ * @returns {string}
+ */
+/**
+ * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
+ * @example (format) => (text) => util.styleText(format, text)
+ *
+ * @param {string} code
+ * @param {boolean} [supported]
+ * @returns {WrapAnsi}
+ *
+ */
+export const wrapAnsiColor = (code, supported = SUPPORTS_COLOR) => {
+  if (supported) {
+    return (text) => code + text + ANSI_RESET
+  }
+
+  return (text) => text
+}
+
+export const red = wrapAnsiColor('\u001B[0;31m')
+export const green = wrapAnsiColor('\u001B[0;32m')
+export const yellow = wrapAnsiColor('\u001B[0;33m')
+export const blue = wrapAnsiColor('\u001B[0;34m')
+export const blackBright = wrapAnsiColor('\u001B[0;90m')
+export const bold = wrapAnsiColor('\u001b[1m')

package/lib/debug.js

@@ -0,0 +1,27 @@
+import { formatWithOptions } from 'node:util'
+
+import { blackBright, SUPPORTS_COLOR } from './colors.js'
+
+const format = (...args) => formatWithOptions({ colors: SUPPORTS_COLOR }, ...args)
+
+let activeLogger
+
+export const enableDebug = (logger = console) => {
+  if (!activeLogger) {
+    activeLogger = logger
+  }
+}
+
+/** @param {string} name */
+export const createDebug = (name) => {
+  let previous = process.hrtime.bigint()
+
+  return (...args) => {
+    if (!activeLogger) return
+
+    const now = process.hrtime.bigint()
+    const ms = (now - previous) / 1_000_000n
+    previous = now
+    activeLogger.debug(blackBright(name + ': ') + format(...args) + blackBright(` +${ms}ms`))
+  }
+}

package/lib/execGit.js

@@ -1,7 +1,8 @@
-import debug from 'debug'
 import spawn, { SubprocessError } from 'nano-spawn'
 
-const debugLog = debug('lint-staged:execGit')
+import { createDebug } from './debug.js'
+
+const debugLog = createDebug('lint-staged:execGit')
 
 /**
  * Explicitly never recurse commands into submodules, overriding local/global configuration.

package/lib/figures.js

@@ -1,8 +1,9 @@
-import chalk from 'chalk'
 import { figures } from 'listr2'
 
-export const info = chalk.blue(figures.arrowRight)
+import { blue, red, yellow } from './colors.js'
 
-export const error = chalk.redBright(figures.cross)
+export const info = blue(figures.arrowRight)
 
-export const warning = chalk.yellow(figures.warning)
+export const error = red(figures.cross)
+
+export const warning = yellow(figures.warning)

package/lib/file.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises'
 
-import debug from 'debug'
+import { createDebug } from './debug.js'
 
-const debugLog = debug('lint-staged:file')
+const debugLog = createDebug('lint-staged:file')
 
 /**
  * Read contents of a file to buffer

package/lib/generateTasks.js

@@ -1,11 +1,11 @@
 import path from 'node:path'
 
-import debug from 'debug'
 import micromatch from 'micromatch'
 
+import { createDebug } from './debug.js'
 import { normalizePath } from './normalizePath.js'
 
-const debugLog = debug('lint-staged:generateTasks')
+const debugLog = createDebug('lint-staged:generateTasks')
 
 /**
  * Generates all task commands, and filelist

package/lib/getFunctionTask.js

@@ -1,8 +1,7 @@
-import debug from 'debug'
-
+import { createDebug } from './debug.js'
 import { makeErr } from './getSpawnedTask.js'
 
-const debugLog = debug('lint-staged:getFunctionTasks')
+const debugLog = createDebug('lint-staged:getFunctionTasks')
 
 /**
  * @typedef {{ title: string; task: Function }} FunctionTask

package/lib/getRenderer.js

@@ -13,7 +13,7 @@ const bindLogger = (consoleLogMethod) =>
     },
   })
 
-const getMainRendererOptions = ({ debug, quiet }, logger, env) => {
+const getMainRendererOptions = ({ color, debug, quiet }, logger, env) => {
   if (quiet) {
     return {
       renderer: 'silent',
@@ -31,8 +31,7 @@ const getMainRendererOptions = ({ debug, quiet }, logger, env) => {
     }
   }
 
-  // Better support for dumb terminals: https://en.wikipedia.org/wiki/Computer_terminal#Dumb_terminals
-  if (debug || env.TERM === 'dumb') {
+  if (debug || !color) {
     return {
       renderer: 'verbose',
     }
@@ -46,19 +45,19 @@ const getMainRendererOptions = ({ debug, quiet }, logger, env) => {
   }
 }
 
-const getFallbackRenderer = ({ renderer }, { FORCE_COLOR }) => {
-  if (renderer === 'silent' || renderer === 'test' || Number(FORCE_COLOR) > 0) {
+const getFallbackRenderer = ({ renderer }, { color = false }) => {
+  if (renderer === 'silent' || renderer === 'test' || !color) {
     return renderer
   }
 
   return 'verbose'
 }
 
-export const getRenderer = (options, logger, env = process.env) => {
-  const mainRendererOptions = getMainRendererOptions(options, logger, env)
+export const getRenderer = ({ color, debug, quiet }, logger, env = process.env) => {
+  const mainRendererOptions = getMainRendererOptions({ color, debug, quiet }, logger, env)
 
   return {
     ...mainRendererOptions,
-    fallbackRenderer: getFallbackRenderer(mainRendererOptions, env),
+    fallbackRenderer: getFallbackRenderer(mainRendererOptions, { color }),
   }
 }