@depup/lint-staged 16.3.2-depup.0

package/lib/index.js

@@ -0,0 +1,184 @@
+import { SUPPORTS_COLOR } from './colors.js'
+import { createDebug, enableDebug } from './debug.js'
+import { execGit } from './execGit.js'
+import {
+  GIT_ERROR,
+  NO_CONFIGURATION,
+  PREVENTED_EMPTY_COMMIT,
+  PREVENTED_TASK_MODIFICATIONS,
+  restoreStashExample,
+  UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
+} from './messages.js'
+import { printTaskOutput } from './printTaskOutput.js'
+import { runAll } from './runAll.js'
+import { cleanupSkipped } from './state.js'
+import {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  FailOnChangesError,
+  GetBackupStashError,
+  GitError,
+  RestoreUnstagedChangesError,
+} from './symbols.js'
+import { validateOptions } from './validateOptions.js'
+import { getVersion } from './version.js'
+
+const debugLog = createDebug('lint-staged')
+
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ */
+const getMaxArgLength = () => {
+  switch (process.platform) {
+    case 'darwin':
+      return 262144
+    case 'win32':
+      return 8191
+    default:
+      return 131072
+  }
+}
+
+/**
+ * @typedef {(...any) => void} LogFunction
+ * @typedef {{ error: LogFunction, log: LogFunction, warn: LogFunction }} Logger
+ *
+ * Root lint-staged function that is called from `bin/lint-staged`.
+ *
+ * @param {object} options
+ * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {boolean} [options.color] - Enable or disable ANSI color codes in output.
+ * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
+ * @param {object}  [options.config] - Object with configuration for programmatic API
+ * @param {string} [options.configPath] - Path to configuration file
+ * @param {boolean} [options.continueOnError] - Run all tasks to completion even if one fails
+ * @param {Object} [options.cwd] - Current working directory
+ * @param {boolean} [options.debug] - Enable debug mode
+ * @param {string} [options.diff] - Override the default "--staged" flag of "git diff" to get list of files
+ * @param {string} [options.diffFilter] - Override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
+ * @param {boolean} [options.failOnChanges] - Fail with exit code 1 when tasks modify tracked files
+ * @param {boolean} [options.hidePartiallyStaged] - Whether to hide unstaged changes from partially staged files before running tasks
+ * @param {boolean} [options.hideUnstaged] - Whether to hide all unstaged changes before running tasks
+ * @param {number} [options.maxArgLength] - Maximum argument string length
+ * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
+ * @param {boolean} [options.relative] - Pass relative filepaths to tasks
+ * @param {boolean} [options.revert] - revert to original state in case of errors
+ * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
+ * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
+ * @param {Logger} [logger]
+ *
+ * @returns {Promise<boolean>} Promise of whether the task passed or failed
+ */
+const lintStaged = async (
+  {
+    allowEmpty = false,
+    color = SUPPORTS_COLOR,
+    concurrent = true,
+    config: configObject,
+    configPath,
+    continueOnError = false,
+    cwd,
+    debug = false,
+    diff,
+    diffFilter,
+    failOnChanges = false,
+    hideUnstaged = false,
+    hidePartiallyStaged = !hideUnstaged,
+    maxArgLength = getMaxArgLength() / 2,
+    quiet = false,
+    relative = false,
+    // Stashing should be disabled by default when the `diff` option is used
+    stash = diff === undefined,
+    // Default to false when using failOnChanges; cannot revert to original state without stash
+    revert = !failOnChanges && !!stash,
+    verbose = false,
+  } = {},
+  logger = console
+) => {
+  // Seemingly enable debug twice (also done in bin), so that it also works when using the Node.js API
+  if (debug) {
+    enableDebug(logger)
+
+    debugLog(
+      'Running `lint-staged@%s` on Node.js %s (%s)',
+      await getVersion(),
+      process.version,
+      process.platform
+    )
+  }
+
+  const gitVersion = await execGit(['version', '--build-options'], { cwd })
+  debugLog('%s', gitVersion)
+
+  const options = {
+    allowEmpty,
+    color,
+    concurrent,
+    configObject,
+    configPath,
+    continueOnError,
+    cwd,
+    debug,
+    diff,
+    diffFilter,
+    failOnChanges,
+    hidePartiallyStaged,
+    hideUnstaged,
+    maxArgLength,
+    quiet,
+    relative,
+    revert,
+    stash,
+    verbose,
+  }
+
+  await validateOptions(options, logger)
+
+  // Unset GIT_LITERAL_PATHSPECS to not mess with path interpretation
+  debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
+  delete process.env.GIT_LITERAL_PATHSPECS
+
+  try {
+    const ctx = await runAll(options, logger)
+    debugLog('Tasks were executed successfully!')
+    printTaskOutput(ctx, logger)
+    return true
+  } catch (runAllError) {
+    if (runAllError?.ctx?.errors) {
+      const { ctx } = runAllError
+
+      if (ctx.errors.has(ConfigNotFoundError)) {
+        logger.error(NO_CONFIGURATION)
+      } else if (ctx.errors.has(ApplyEmptyCommitError)) {
+        logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (ctx.errors.has(FailOnChangesError)) {
+        logger.warn(PREVENTED_TASK_MODIFICATIONS + '\n')
+        logger.warn(restoreStashExample(ctx.backupHash))
+      } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
+        logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
+        logger.warn(ctx.unstagedPatch)
+      } else if (
+        (ctx.errors.has(GitError) || cleanupSkipped(ctx)) &&
+        !ctx.errors.has(GetBackupStashError)
+      ) {
+        logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(restoreStashExample(ctx.backupHash) + '\n')
+        }
+      }
+
+      printTaskOutput(ctx, logger)
+      return false
+    }
+
+    // Probably a compilation error in the config js file. Pass it up to the outer error handler for logging.
+    throw runAllError
+  }
+}
+
+export default lintStaged

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

@@ -0,0 +1,102 @@
+/** @typedef {import('./index').Logger} Logger */
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { CONFIG_NAME, PACKAGE_JSON_FILE, PACKAGE_YAML_FILES } from './configFiles.js'
+import { createDebug } from './debug.js'
+import { failedToLoadConfig } from './messages.js'
+import { resolveConfig } from './resolveConfig.js'
+
+const debugLog = createDebug('lint-staged:loadConfig')
+
+const readFile = async (filename) => fs.readFile(path.resolve(filename), 'utf-8')
+
+const jsonParse = async (filename) => {
+  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filename))
+  try {
+    const content = await readFile(filename)
+    const json = JSON.parse(content)
+    return isPackageFile ? json[CONFIG_NAME] : json
+  } catch (error) {
+    if (path.basename(filename) === PACKAGE_JSON_FILE) {
+      debugLog('Ignoring invalid JSON file %s', filename)
+      return undefined
+    }
+
+    throw error
+  }
+}
+
+const yamlParse = async (filename) => {
+  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filename))
+  try {
+    const [YAML, content] = await Promise.all([import('yaml'), readFile(filename)])
+    const yaml = YAML.parse(content)
+    return isPackageFile ? yaml[CONFIG_NAME] : yaml
+  } catch (error) {
+    if (isPackageFile) {
+      debugLog('Ignoring invalid YAML file %s', filename)
+      return undefined
+    }
+
+    throw error
+  }
+}
+
+export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)
+
+const NO_EXT = 'noExt'
+
+/**
+ * `lilconfig` doesn't support yaml files by default,
+ * so we add custom loaders for those. Files without
+ * an extensions are assumed to be yaml — this
+ * assumption is in `cosmiconfig` as well.
+ */
+const loaders = {
+  [NO_EXT]: yamlParse,
+  '.cjs': dynamicImport,
+  '.cts': dynamicImport,
+  '.js': dynamicImport,
+  '.json': jsonParse,
+  '.mjs': dynamicImport,
+  '.mts': dynamicImport,
+  '.ts': dynamicImport,
+  '.yaml': yamlParse,
+  '.yml': yamlParse,
+}
+
+const loadConfigByExt = async (filename) => {
+  const filepath = path.resolve(filename)
+  const ext = path.extname(filepath) || NO_EXT
+  const loader = loaders[ext]
+  const config = await loader(filepath)
+
+  return { config, filepath }
+}
+
+/** @param {string} configPath */
+export const loadConfig = async (configPath, logger) => {
+  try {
+    debugLog('Loading configuration from `%s`...', configPath)
+    const result = await loadConfigByExt(resolveConfig(configPath))
+
+    // config is a promise when using the `dynamicImport` loader
+    const config = (await result.config) ?? null
+    const filepath = result.filepath
+
+    if (config) {
+      debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+    } else {
+      debugLog('Found no config in %s', filepath)
+    }
+
+    return { config, filepath }
+  } catch (error) {
+    debugLog('Failed to load configuration from `%s` with error:\n', configPath, error)
+    logger.error(failedToLoadConfig(configPath))
+    return {}
+  }
+}

package/lib/messages.js

@@ -0,0 +1,91 @@
+import { inspect } from 'node:util'
+
+import { bold, red, yellow } from './colors.js'
+import { error, info, warning } from './figures.js'
+
+export const configurationError = (opt, helpMsg, value) =>
+  `${red(`${error} Validation Error:`)}
+
+  Invalid value for '${bold(opt)}': ${bold(inspect(value))}
+
+  ${helpMsg}`
+
+export const NOT_GIT_REPO = red(`${error} Current directory is not a git directory!`)
+
+export const FAILED_GET_STAGED_FILES = red(`${error} Failed to get staged files!`)
+
+export const incorrectBraces = (before, after) =>
+  yellow(
+    `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
+`
+  )
+
+export const NO_CONFIGURATION = `${error} lint-staged could not find any valid configuration.`
+
+export const NO_STAGED_FILES = `${info} lint-staged could not find any staged files.`
+
+export const NO_TASKS = `${info} lint-staged could not find any staged files matching configured tasks.`
+
+export const skippingBackup = (hasInitialCommit, diff) => {
+  const reason =
+    diff !== undefined
+      ? '`--diff` was used'
+      : (hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet') +
+        '. This might result in data loss'
+
+  return yellow(`${warning} Skipping backup because ${reason}.\n`)
+}
+
+export const SKIPPING_HIDE_PARTIALLY_CHANGED = yellow(
+  `${warning} Skipping hiding unstaged changes from partially staged files because \`--no-hide-partially-staged\` was used.\n`
+)
+
+export const DEPRECATED_GIT_ADD = yellow(
+  `${warning} Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.
+`
+)
+
+export const TASK_ERROR = 'Skipped because of errors from tasks.'
+
+export const PREVENTED_TASK_MODIFICATIONS = `\n${error} lint-staged failed because \`--fail-on-changes\` was used.`
+
+export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+
+export const GIT_ERROR = `\n  ${red(`${error} lint-staged failed due to a git error.`)}`
+
+export const invalidOption = (name, value, message) => `${red(`${error} Validation Error:`)}
+
+  Invalid value for option '${bold(name)}': ${bold(value)}
+
+  ${message}
+
+See https://github.com/okonet/lint-staged#command-line-flags`
+
+export const PREVENTED_EMPTY_COMMIT = `
+  ${yellow(`${warning} lint-staged prevented an empty git commit.
+  Use the --allow-empty option to continue, or check your task configuration`)}
+`
+
+export const restoreStashExample = (
+  hash = 'h0a0s0h0'
+) => `Any lost modifications can be restored from a git stash:
+
+  > git stash list --format="%h %s"
+  ${hash} On main: lint-staged automatic backup
+  > git apply --index ${hash}`
+
+export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
+
+export const failedToLoadConfig = (filepath) =>
+  red(`${error} Failed to read config from file "${filepath}".`)
+
+export const failedToParseConfig = (
+  filepath,
+  error
+) => `${red(`${error} Failed to parse config from file "${filepath}".`)}
+
+${error}
+
+See https://github.com/okonet/lint-staged#configuration.`
+
+export const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `Unstaged changes have been kept back in a patch file:`

package/lib/normalizePath.js

@@ -0,0 +1,50 @@
+/**
+ * Reimplementation of "normalize-path"
+ * @see https://github.com/jonschlinkert/normalize-path/blob/52c3a95ebebc2d98c1ad7606cbafa7e658656899/index.js
+ */
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+import path from 'node:path'
+
+/**
+ * A file starting with \\?\
+ * @see https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#win32-file-namespaces
+ */
+const WIN32_FILE_NS = '\\\\?\\'
+
+/**
+ * A file starting with \\.\
+ * @see https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#win32-file-namespaces
+ */
+const WIN32_DEVICE_NS = '\\\\.\\'
+
+/**
+ * Normalize input file path to use POSIX separators
+ * @param {String} input
+ * @returns String
+ */
+export const normalizePath = (input) => {
+  if (input === path.posix.sep || input === path.win32.sep) {
+    return path.posix.sep
+  }
+
+  let normalized = input.split(/[/\\]+/).join(path.posix.sep)
+
+  /** Handle win32 Namespaced paths by changing e.g. \\.\ to //./ */
+  if (input.startsWith(WIN32_FILE_NS) || input.startsWith(WIN32_DEVICE_NS)) {
+    normalized = normalized.replace(/^\/(\.|\?)/, '//$1')
+  }
+
+  /** Remove trailing slash */
+  if (normalized.endsWith(path.posix.sep)) {
+    normalized = normalized.slice(0, -1)
+  }
+
+  return normalized
+}

package/lib/parseGitZOutput.js

@@ -0,0 +1,11 @@
+/**
+ * Return array of strings split from the output of `git <something> -z`.
+ * With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
+ * remove the last occurrence of `\u0000` before splitting
+ */
+export const parseGitZOutput = (input) =>
+  input
+    ? input
+        .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
+        .split('\u0000')
+    : []

package/lib/printTaskOutput.js

@@ -0,0 +1,12 @@
+/**
+ * Handle logging of listr `ctx.output` to the specified `logger`
+ * @param {Object} ctx - The listr initial state
+ * @param {Object} logger - The logger
+ */
+export const printTaskOutput = (ctx = {}, logger) => {
+  if (!Array.isArray(ctx.output)) return
+  const log = ctx.errors?.size > 0 ? logger.error : logger.log
+  for (const line of ctx.output) {
+    log(line)
+  }
+}

package/lib/readStdin.js

@@ -0,0 +1,19 @@
+import { createInterface } from 'node:readline'
+
+/**
+ * Returns a promise resolving to the first line written to stdin after invoking.
+ * @warn will never resolve if called after writing to stdin
+ *
+ * @returns {Promise<string>}
+ */
+export const readStdin = () => {
+  const readline = createInterface({ input: process.stdin })
+
+  return new Promise((resolve) => {
+    readline.prompt()
+    readline.on('line', (line) => {
+      readline.close()
+      resolve(line)
+    })
+  })
+}

package/lib/resolveConfig.js

@@ -0,0 +1,15 @@
+import { createRequire } from 'node:module'
+
+/**
+ * require() does not exist for ESM, so we must create it to use require.resolve().
+ * @see https://nodejs.org/api/module.html#modulecreaterequirefilename
+ */
+const require = createRequire(import.meta.url)
+
+export function resolveConfig(configPath) {
+  try {
+    return require.resolve(configPath)
+  } catch {
+    return configPath
+  }
+}

package/lib/resolveGitRepo.js

@@ -0,0 +1,65 @@
+import path from 'node:path'
+
+import { createDebug } from './debug.js'
+import { execGit } from './execGit.js'
+import { normalizePath } from './normalizePath.js'
+
+const debugLog = createDebug('lint-staged:resolveGitRepo')
+
+/**
+ * Relative path up to the repo top-level directory
+ * @example "../"
+ */
+const CDUP = '--show-cdup'
+
+/**
+ * Absolute repo top-level directory
+ *
+ * @example <caption>Git on macOS</caption>
+ * "/Users/iiro/Documents/git/lint-staged"
+ *
+ * @example <caption>Git for Windows</caption>
+ * "C:\Users\iiro\Documents\git\lint-staged"
+ *
+ * @example <caption>Git installed with MSYS2, this doesn't work when used as CWD with Node.js child_process</caption>
+ * "/c/Users/iiro/Documents/git/lint-staged"
+ */
+const TOPLEVEL = '--show-toplevel'
+
+/**
+ * Absolute .git directory, similar to top-level
+ *
+ * @example "/Users/iiro/Documents/git/lint-staged/.git"
+ */
+const ABSOLUTE_GIT_DIR = '--absolute-git-dir'
+
+/** Resolve git directory and possible submodule paths */
+export const resolveGitRepo = async (cwd = process.cwd()) => {
+  try {
+    debugLog('Resolving git repo from `%s`', cwd)
+
+    // Unset GIT_DIR before running any git operations in case it's pointing to an incorrect location
+    debugLog('Unset GIT_DIR (was `%s`)', process.env.GIT_DIR)
+    delete process.env.GIT_DIR
+    debugLog('Unset GIT_WORK_TREE (was `%s`)', process.env.GIT_WORK_TREE)
+    delete process.env.GIT_WORK_TREE
+
+    /** Git rev-parse returns all three flag values on separate lines  */
+    const revParseOutput = await execGit(['rev-parse', CDUP, TOPLEVEL, ABSOLUTE_GIT_DIR], {
+      cwd,
+    })
+    const [relativeTopLevelDir, topLevel, absoluteGitDir] = revParseOutput.split('\n')
+
+    const topLevelDir = normalizePath(path.join(cwd, relativeTopLevelDir))
+    debugLog('Resolved git repository top-level directory to be `%s`', topLevelDir)
+
+    const relativeGitConfigDir = path.relative(topLevel, absoluteGitDir)
+    const gitConfigDir = normalizePath(path.join(topLevelDir, relativeGitConfigDir))
+    debugLog('Resolved git config directory to be `%s`', gitConfigDir)
+
+    return { topLevelDir, gitConfigDir }
+  } catch (error) {
+    debugLog('Failed to resolve git repo with error:', error)
+    return { error, topLevelDir: null, gitConfigDir: null }
+  }
+}