@depup/lint-staged 16.3.2-depup.0

package/bin/lint-staged.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import { userInfo } from 'node:os'
+
+import { Option, program } from 'commander'
+
+import { createDebug, enableDebug } from '../lib/debug.js'
+import lintStaged from '../lib/index.js'
+import { CONFIG_STDIN_ERROR, restoreStashExample } from '../lib/messages.js'
+import { readStdin } from '../lib/readStdin.js'
+import { getVersion } from '../lib/version.js'
+
+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
+   * */
+  .allowExcessArguments()
+
+  .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.
+   */
+  .addOption(
+    new Option('--revert', 'revert to original state in case of errors').default(true).hideHelp()
+  )
+  .addOption(
+    new Option('--no-revert', 'do not revert to original state in case of errors.').default(false)
+  )
+
+  .addOption(new Option('--stash', 'enable the backup stash').default(true).hideHelp())
+  .addOption(
+    new Option('--no-stash', 'disable the backup stash. Implies "--no-revert".')
+      .default(false)
+      .implies({ revert: false })
+  )
+
+  .addOption(
+    new Option('--hide-partially-staged', 'hide unstaged changes from partially staged files')
+      .default(true)
+      .hideHelp()
+  )
+  .addOption(
+    new Option(
+      '--no-hide-partially-staged',
+      'disable hiding unstaged changes from partially staged files'
+    ).default(false)
+  )
+
+  .addOption(
+    new Option('--hide-unstaged', 'hide all unstaged changes, instead of just partially staged')
+      .default(false)
+      .implies({ hidePartiallyStaged: 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)
+  )
+
+  .addHelpText('afterAll', '\n' + restoreStashExample())
+
+const cliOptions = program.parse(process.argv).opts()
+
+if (cliOptions.debug) {
+  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`
+  verbose: !!cliOptions.verbose,
+}
+
+try {
+  const { shell } = userInfo()
+  debugLog('Using shell: %s', shell)
+} catch {
+  debugLog('Could not determine current shell')
+}
+
+debugLog('Options parsed from command-line: %o', options)
+
+if (options.configPath === '-') {
+  delete options.configPath
+  try {
+    debugLog('Reading config from stdin')
+    options.config = JSON.parse(await readStdin())
+  } catch (error) {
+    debugLog(CONFIG_STDIN_ERROR, error)
+    console.error(CONFIG_STDIN_ERROR)
+    process.exit(1)
+  }
+}
+
+const passed = await lintStaged(options)
+if (!passed) {
+  process.exitCode = 1
+}

package/lib/chunkFiles.js

@@ -0,0 +1,65 @@
+import path from 'node:path'
+
+import { createDebug } from './debug.js'
+import { normalizePath } from './normalizePath.js'
+
+const debugLog = createDebug('lint-staged:chunkFiles')
+
+/**
+ * Chunk array into sub-arrays
+ * @param {Array} arr
+ * @param {Number} chunkCount
+ * @returns {Array<Array>}
+ */
+const chunkArray = (arr, chunkCount) => {
+  if (chunkCount === 1) return [arr]
+  const chunked = []
+  let position = 0
+  for (let i = 0; i < chunkCount; i++) {
+    const chunkLength = Math.ceil((arr.length - position) / (chunkCount - i))
+    chunked.push([])
+    chunked[i] = arr.slice(position, chunkLength + position)
+    position += chunkLength
+  }
+  return chunked
+}
+
+/**
+ * Chunk files into sub-arrays based on the length of the resulting argument string
+ *
+ * @typedef {import('./getStagedFiles.js').StagedFile[]} StagedFile
+ *
+ * @param {Object} opts
+ * @param {Array<StagedFile>} opts.files
+ * @param {String} [opts.baseDir] The optional base directory to resolve relative paths.
+ * @param {number} [opts.maxArgLength] the maximum argument string length
+ * @param {Boolean} [opts.relative] whether files are relative to `topLevelDir` or should be resolved as absolute
+ * @returns {Array<Array<StagedFile>>}
+ */
+export const chunkFiles = ({ files, baseDir, maxArgLength = null, relative = false }) => {
+  const normalizedFiles = files.map((file) => {
+    return {
+      filepath: normalizePath(
+        relative || !baseDir ? file.filepath : path.resolve(baseDir, file.filepath)
+      ),
+      status: file.status,
+    }
+  })
+
+  if (!maxArgLength) {
+    debugLog('Skip chunking files because of undefined maxArgLength')
+    return [normalizedFiles] // wrap in an array to return a single chunk
+  }
+
+  /** Calculate total character length of all filepaths, with added spaces in between */
+  const fileListLength =
+    normalizedFiles.reduce((sum, file) => sum + file.filepath.length, 0) +
+    Math.max(normalizedFiles.length - 1, 0)
+
+  debugLog(
+    `Resolved an argument string length of ${fileListLength} characters from ${normalizedFiles.length} files`
+  )
+  const chunkCount = Math.min(Math.ceil(fileListLength / maxArgLength), normalizedFiles.length)
+  debugLog(`Creating ${chunkCount} chunks for maxArgLength of ${maxArgLength}`)
+  return chunkArray(normalizedFiles, chunkCount)
+}

package/lib/colors.js

@@ -0,0 +1,106 @@
+import nodeTty from 'node:tty'
+
+/**
+ * @example NO_COLOR
+ * @example NO_COLOR=1
+ * @example NO_COLOR=true
+ */
+const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
+
+/**
+ * @example FORCE_COLOR=0
+ * @example 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/configFiles.js

@@ -0,0 +1,30 @@
+export const CONFIG_NAME = 'lint-staged'
+
+export const PACKAGE_JSON_FILE = 'package.json'
+
+export const PACKAGE_YAML_FILES = ['package.yaml', 'package.yml']
+
+/**
+ * The list of files `lint-staged` will read configuration
+ * from, in the declared order.
+ */
+export const CONFIG_FILE_NAMES = [
+  PACKAGE_JSON_FILE,
+  ...PACKAGE_YAML_FILES,
+  '.lintstagedrc',
+  '.lintstagedrc.json',
+  '.lintstagedrc.yaml',
+  '.lintstagedrc.yml',
+  '.lintstagedrc.mjs',
+  '.lintstagedrc.mts',
+  '.lintstagedrc.js',
+  '.lintstagedrc.ts',
+  '.lintstagedrc.cjs',
+  '.lintstagedrc.cts',
+  'lint-staged.config.mjs',
+  'lint-staged.config.mts',
+  'lint-staged.config.js',
+  'lint-staged.config.ts',
+  'lint-staged.config.cjs',
+  'lint-staged.config.cts',
+]

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

@@ -0,0 +1,37 @@
+import { exec } from 'tinyexec'
+
+import { createDebug } from './debug.js'
+
+const debugLog = createDebug('lint-staged:execGit')
+
+/**
+ * Explicitly never recurse commands into submodules, overriding local/global configuration.
+ * @see https://git-scm.com/docs/git-config#Documentation/git-config.txt-submodulerecurse
+ */
+const NO_SUBMODULE_RECURSE = ['-c', 'submodule.recurse=false']
+
+// exported for tests
+export const GIT_GLOBAL_OPTIONS = [...NO_SUBMODULE_RECURSE]
+
+/** @type {(cmd: string[], options?: { cwd?: string }) => Promise<string>} */
+export const execGit = async (cmd, options) => {
+  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/figures.js

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

package/lib/file.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises'
+
+import { createDebug } from './debug.js'
+
+const debugLog = createDebug('lint-staged:file')
+
+/**
+ * Read contents of a file to buffer
+ * @param {String} filename
+ * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
+ * @returns {Promise<Buffer>}
+ */
+export const readFile = async (filename, ignoreENOENT = true) => {
+  debugLog('Reading file `%s`', filename)
+  try {
+    return await fs.readFile(filename)
+  } catch (error) {
+    if (ignoreENOENT && error.code === 'ENOENT') {
+      debugLog("File `%s` doesn't exist, ignoring...", filename)
+      return null // no-op file doesn't exist
+    } else {
+      throw error
+    }
+  }
+}
+
+/**
+ * Remove a file
+ * @param {String} filename
+ * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
+ */
+export const unlink = async (filename, ignoreENOENT = true) => {
+  debugLog('Removing file `%s`', filename)
+  try {
+    await fs.unlink(filename)
+  } catch (error) {
+    if (ignoreENOENT && error.code === 'ENOENT') {
+      debugLog("File `%s` doesn't exist, ignoring...", filename)
+    } else {
+      throw error
+    }
+  }
+}
+
+/**
+ * Write buffer to file
+ * @param {String} filename
+ * @param {Buffer} buffer
+ */
+export const writeFile = async (filename, buffer) => {
+  debugLog('Writing file `%s`', filename)
+  await fs.writeFile(filename, buffer)
+}

package/lib/generateTasks.js

@@ -0,0 +1,69 @@
+import path from 'node:path'
+
+import micromatch from 'micromatch'
+
+import { createDebug } from './debug.js'
+import { normalizePath } from './normalizePath.js'
+
+const debugLog = createDebug('lint-staged:generateTasks')
+
+/**
+ * Generates all task commands, and filelist
+ *
+ * @param {object} options
+ * @param {Object} [options.config] - Task configuration
+ * @param {Object} [options.cwd] - Current working directory
+ * @param {import('./getStagedFiles.js').StagedFile[]} [options.files] - Staged filepaths
+ * @param {boolean} [options.relative] - Whether filepaths to should be relative to cwd
+ */
+export const generateTasks = ({ config, cwd = process.cwd(), files, relative = false }) => {
+  debugLog('Generating linter tasks')
+
+  /** @type {StagedFile[]} */
+  const relativeFiles = files.map((file) => ({
+    filepath: normalizePath(path.relative(cwd, file.filepath)),
+    status: file.status,
+  }))
+
+  return Object.entries(config).map(([pattern, commands]) => {
+    const isParentDirPattern = pattern.startsWith('../')
+
+    // Only worry about children of the CWD unless the pattern explicitly
+    // specifies that it concerns a parent directory.
+    const filteredFiles = relativeFiles.filter((file) => {
+      if (isParentDirPattern) return true
+      return !file.filepath.startsWith('..') && !path.isAbsolute(file.filepath)
+    })
+
+    const matches = micromatch(
+      filteredFiles.map((file) => file.filepath),
+      pattern,
+      {
+        cwd,
+        dot: true,
+        // If the pattern doesn't look like a path, enable `matchBase` to
+        // match against filenames in every directory. This makes `*.js`
+        // match both `test.js` and `subdirectory/test.js`.
+        matchBase: !pattern.includes('/'),
+        posixSlashes: true,
+        strictBrackets: true,
+      }
+    )
+
+    const fileList = filteredFiles.flatMap((file) =>
+      matches.includes(file.filepath)
+        ? [
+            {
+              filepath: normalizePath(relative ? file.filepath : path.resolve(cwd, file.filepath)),
+              status: file.status,
+            },
+          ]
+        : []
+    )
+
+    const task = { pattern, commands, fileList }
+    debugLog('Generated task: \n%O', task)
+
+    return task
+  })
+}

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/getDiffCommand.js

@@ -0,0 +1,19 @@
+/** @type {(diff?: string, diffFilter?: string) => string[]} */
+export const getDiffCommand = (diff, diffFilter) => {
+  /**
+   *  Docs for --diff-filter option:
+   * @see https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203
+   */
+  const diffFilterArg = diffFilter !== undefined ? diffFilter.trim() : 'ACMR'
+
+  /** Use `--diff branch1...branch2` or `--diff="branch1 branch2", or fall back to default staged files */
+  const diffArgs = diff !== undefined ? diff.trim().split(' ') : ['--staged']
+
+  /**
+   * Docs for -z option:
+   * @see https://git-scm.com/docs/git-diff#Documentation/git-diff.txt--z
+   */
+  const diffCommand = ['diff', `--diff-filter=${diffFilterArg}`, ...diffArgs]
+
+  return diffCommand
+}

package/lib/getFunctionTask.js

@@ -0,0 +1,37 @@
+import { createDebug } from './debug.js'
+import { createTaskError } from './getSpawnedTask.js'
+
+const debugLog = createDebug('lint-staged:getFunctionTasks')
+
+/**
+ * @typedef {{ title: string; task: Function }} FunctionTask
+ * @type {(commands: FunctionTask|Array<string|Function>|string|Function) => boolean}
+ * @returns `true` if command is a function task
+ */
+export const isFunctionTask = (commands) => typeof commands === 'object' && !Array.isArray(commands)
+
+/**
+ * Handles function configuration and pushes the tasks into the task array
+ *
+ * @param {object} command
+ * @param {import('./getStagedFiles.js').StagedFile[]} files
+ * @throws {Error} If the function configuration is not valid
+ */
+export const getFunctionTask = async (command, files) => {
+  debugLog('Creating Listr tasks for function %o', command)
+
+  const task = async (ctx) => {
+    try {
+      await command.task(files.map((file) => file.filepath))
+    } catch (e) {
+      throw createTaskError(command.title, e, ctx)
+    }
+  }
+
+  return [
+    {
+      title: command.title,
+      task,
+    },
+  ]
+}