@depup/lint-staged 16.3.2-depup.0

package/lib/getRenderer.js

@@ -0,0 +1,63 @@
+import { EOL } from 'node:os'
+import { Writable } from 'node:stream'
+
+import { ListrLogger, ProcessOutput } from 'listr2'
+
+const EOLRegex = new RegExp(EOL + '$')
+
+const bindLogger = (consoleLogMethod) =>
+  new Writable({
+    write: function (chunk, encoding, next) {
+      consoleLogMethod(chunk.toString().replace(EOLRegex, ''))
+      next()
+    },
+  })
+
+const getMainRendererOptions = ({ color, debug, quiet }, logger, env) => {
+  if (quiet) {
+    return {
+      renderer: 'silent',
+    }
+  }
+
+  if (env.NODE_ENV === 'test') {
+    return {
+      renderer: 'test',
+      rendererOptions: {
+        logger: new ListrLogger({
+          processOutput: new ProcessOutput(bindLogger(logger.log), bindLogger(logger.error)),
+        }),
+      },
+    }
+  }
+
+  if (debug || !color) {
+    return {
+      renderer: 'verbose',
+    }
+  }
+
+  return {
+    renderer: 'update',
+    rendererOptions: {
+      formatOutput: 'truncate',
+    },
+  }
+}
+
+const getFallbackRenderer = ({ renderer }, { color = false }) => {
+  if (renderer === 'silent' || renderer === 'test' || !color) {
+    return renderer
+  }
+
+  return 'verbose'
+}
+
+export const getRenderer = ({ color, debug, quiet }, logger, env = process.env) => {
+  const mainRendererOptions = getMainRendererOptions({ color, debug, quiet }, logger, env)
+
+  return {
+    ...mainRendererOptions,
+    fallbackRenderer: getFallbackRenderer(mainRendererOptions, { color }),
+  }
+}

package/lib/getSpawnedTask.js

@@ -0,0 +1,160 @@
+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 debugLog = createDebug('lint-staged:getSpawnedTask')
+
+/**
+ * Handle task console output.
+ *
+ * @param {string} command
+ * @param {string} output
+ * @param {ReturnType<typeof getInitialState>} ctx context
+ * @param {keyof typeof Signal | undefined} signal
+ * @param {import('tinyexec').Result} [errorResult]
+ */
+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 (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)
+  }
+}
+
+/**
+ * Create a error output depending on process result.
+ *
+ * @param {string} command
+ * @param {import('tinyexec').Result} result
+ * @param {ReturnType<typeof getInitialState>} ctx context
+ * @param {keyof typeof Signal | undefined} signal
+ * @returns {Error}
+ */
+export const createTaskError = (command, result, ctx, signal = 'FAILED') => {
+  ctx.errors.add(TaskError)
+  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]
+ * @param {string} [options.cwd]
+ * @param {String} options.topLevelDir - Current git repo top-level path
+ * @param {Boolean} options.isFn - Whether the linter task is a function
+ * @param {string[]} options.files — Filepaths to run the linter task against
+ * @param {Boolean} [options.verbose] — Always show task verbose
+ * @returns {() => Promise<Array<string>>}
+ */
+export const getSpawnedTask = ({
+  abortController,
+  color,
+  command,
+  continueOnError = false,
+  cwd = process.cwd(),
+  files,
+  topLevelDir,
+  isFn,
+  verbose = false,
+}) => {
+  const [cmd, ...args] = parseArgsStringToArgv(command)
+  debugLog('cmd:', cmd)
+  debugLog('args:', args)
+
+  /** @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,
+      env: color ? { FORCE_COLOR: 'true' } : { NO_COLOR: 'true' },
+      stdio: ['ignore'],
+    },
+  }
+
+  debugLog('Tinyexec options:', tinyExecOptions)
+
+  /** @param {ReturnType<typeof getInitialState>} ctx context */
+  return async (ctx = getInitialState()) => {
+    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 {
+      for await (const line of result) {
+        output += line + '\n'
+      }
+    } catch (error) {
+      /** 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

@@ -0,0 +1,76 @@
+import { createDebug } from './debug.js'
+import { getSpawnedTask } from './getSpawnedTask.js'
+import { configurationError } from './messages.js'
+
+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
+ * @param {string} options.cwd
+ * @param {import('./getStagedFiles.js').StagedFile[]} options.files
+ * @param {string} options.topLevelDir
+ * @param {Boolean} verbose
+ */
+export const getSpawnedTasks = async ({
+  abortController,
+  color,
+  commands,
+  continueOnError,
+  cwd,
+  files,
+  topLevelDir,
+  verbose,
+}) => {
+  debugLog('Creating Listr tasks for commands %o', commands)
+  const cmdTasks = []
+
+  const commandArray = Array.isArray(commands) ? commands : [commands]
+
+  const filepaths = files.map((f) => f.filepath)
+
+  for (const cmd of commandArray) {
+    // command function may return array of commands that already include `stagedFiles`
+    const isFn = typeof cmd === 'function'
+
+    /** Pass copy of file list to prevent mutation by function from config file. */
+    const resolved = isFn ? await cmd([...filepaths]) : cmd
+
+    const resolvedArray = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array command as array
+
+    for (const command of resolvedArray) {
+      // If the function linter didn't return string | string[]  it won't work
+      // Do the validation here instead of `validateConfig` to skip evaluating the function multiple times
+      if (isFn && typeof command !== 'string') {
+        throw new Error(
+          configurationError(
+            '[Function]',
+            'Function task should return a string or an array of strings',
+            resolved
+          )
+        )
+      }
+
+      const task = getSpawnedTask({
+        abortController,
+        color,
+        command,
+        continueOnError,
+        cwd,
+        files: filepaths,
+        topLevelDir,
+        isFn,
+        verbose,
+      })
+
+      cmdTasks.push({ title: command, command, task })
+    }
+  }
+
+  return cmdTasks
+}

package/lib/getStagedFiles.js

@@ -0,0 +1,86 @@
+import path from 'node:path'
+
+import { execGit } from './execGit.js'
+import { getDiffCommand } from './getDiffCommand.js'
+import { normalizePath } from './normalizePath.js'
+import { parseGitZOutput } from './parseGitZOutput.js'
+
+/**
+ * @typedef {'A'|'C'|'D'|'M'|'R'|'T'|'U'|'X'} FileSatus
+ * @typedef { { filepath: string; status: FileSatus }} StagedFile
+ *
+ * @param {Object} args
+ * @param {string} [args.cwd]
+ * @param {string} [args.diff]
+ * @param {string} [args.diffFilter]
+ * @retuns {Promise<StagedFile[] | null>}
+ */
+export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } = {}) => {
+  try {
+    /**
+     * With the raw output lines look like:
+     *
+     * :000000 100644 0000000 780ccd3\u0000A\u0000.gitmodules\u0000
+     * :000000 160000 0000000 1bb568e\u0000A\u0000submodule\u0000
+     *
+     * @see https://git-scm.com/docs/git-diff#_raw_output_format
+     */
+    const output = await execGit([...getDiffCommand(diff, diffFilter), '--raw', '-z'], { cwd })
+
+    if (!output) return []
+
+    /**
+     * Split from all colons and remove the first one, after which lines will look like:
+     *
+     * 000000 100644 0000000 780ccd3 A\u0000.gitmodules\u0000
+     * 000000 160000 0000000 47e5cff A\u0000submodule\u0000
+     *
+     * where '\u0000' is the NUL character from '-z' option. After that we
+     * parse the lines by splitting from NUL, and then split the first
+     * part from space. This yields us enough info both filter out submodule
+     * roots and get the filename.
+     */
+    return output
+      .slice(1)
+      .split('\u0000:')
+      .map(parseGitZOutput)
+      .flatMap(([info, src, dst]) => {
+        const [, dstMode, , , statusWithScore] = info.split(' ')
+
+        /**
+         * Filter out submodules and symlinks
+         * @see https://github.com/git/git/blob/cb96e1697ad6e54d11fc920c95f82977f8e438f8/Documentation/git-fast-import.adoc?plain=1#L634-L646
+         */
+        if (dstMode === '160000' || dstMode === '120000') {
+          return []
+        }
+
+        /**
+         * @example "M"
+         * @example "R86"
+         *
+         * - A: addition of a file
+         * - C: copy of a file into a new one
+         * - D: deletion of a file
+         * - M: modification of the contents or mode of a file
+         * - R: renaming of a file
+         * - T: change in the type of the file (regular file, symbolic link or submodule)
+         * - U: file is unmerged (you must complete the merge before it can be committed)
+         * - X: "unknown" change type (most probably a bug, please report it)
+         */
+        const status = statusWithScore[0]
+
+        /** "dst" exists when moving files, otherwise it's undefined and only "src" exists */
+        const filename = dst ?? src
+
+        return [
+          {
+            filepath: normalizePath(path.resolve(cwd, filename)),
+            status,
+          },
+        ]
+      })
+  } catch {
+    return null
+  }
+}