lint-staged 17.0.8 → 17.1.1

package/lib/messages.js

@@ -1,30 +1,32 @@
 import { inspect } from 'node:util'
 
 import { bold, red, yellow } from './colors.js'
-import { error, info, warning } from './figures.js'
+import * as figures from './figures.js'
 
 export const configurationError = (opt, helpMsg, value) =>
-  `${red(`${error} Validation Error:`)}
+  `${red(`${figures.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 notGitRepo = () => red(`${figures.error()} Current directory is not a git directory!`)
 
-export const FAILED_GET_STAGED_FILES = red(`${error} Failed to get staged files!`)
+export const failedGetStagedFiles = () => red(`${figures.error()} Failed to get staged files!`)
 
 export const incorrectBraces = (before, after) =>
   yellow(
-    `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
+    `${figures.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 noConfiguration = () =>
+  `${figures.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 noStagedFiles = () => `${figures.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 noTasks = () =>
+  `${figures.info()} lint-staged could not find any staged files matching configured tasks.`
 
 export const skippingBackup = (hasInitialCommit, diff) => {
   const reason =
@@ -33,27 +35,33 @@ export const skippingBackup = (hasInitialCommit, diff) => {
       : (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`)
+  return yellow(`${figures.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 skippingHidePartiallyChanged = () =>
+  yellow(
+    `${figures.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 deprecatedGitAdd = () =>
+  yellow(
+    `${figures.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 taskError = () => 'Skipped because of errors from tasks.'
 
-export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+export const preventedTaskModifications = () =>
+  `\n${figures.error()} lint-staged failed because \`--fail-on-changes\` was used.`
 
-export const GIT_ERROR = `\n  ${red(`${error} lint-staged failed due to a git error.`)}`
+export const gitError = () =>
+  `\n  ${red(`${figures.error()} lint-staged failed due to a git error.`)}`
 
-export const invalidOption = (name, value, message) => `${red(`${error} Validation Error:`)}
+export const invalidOption = (
+  name,
+  value,
+  message
+) => `${red(`${figures.error()} Validation Error:`)}
 
   Invalid value for option '${bold(name)}': ${bold(value)}
 
@@ -61,8 +69,8 @@ export const invalidOption = (name, value, message) => `${red(`${error} Validati
 
 See https://github.com/lint-staged/lint-staged#command-line-flags`
 
-export const PREVENTED_EMPTY_COMMIT = `
-  ${yellow(`${warning} lint-staged prevented an empty git commit.
+export const preventedEmptyCommit = () => `
+  ${yellow(`${figures.warning()} lint-staged prevented an empty git commit.
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
@@ -75,23 +83,22 @@ export const restoreStashExample = (
   > 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}".`)
+  red(`${figures.error()} Failed to read config from file "${filepath}".`)
 
 export const failedToParseConfig = (
   filepath,
   error
-) => `${red(`${error} Failed to parse config from file "${filepath}".`)}
+) => `${red(`${figures.error()} Failed to parse config from file "${filepath}".`)}
 
 ${error}
 
 See https://github.com/lint-staged/lint-staged#configuration.`
 
-export const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `Unstaged changes have been kept back in a patch file:`
+export const unstagedChangesBackupStashLocation = () =>
+  'Unstaged changes have been kept back in a patch file:'
 
 export const minGitVersionRequired = (expected) =>
-  red(`${error} lint-staged requires at least Git version ${bold(expected)}.
+  red(`${figures.error()} lint-staged requires at least Git version ${bold(expected)}.
 
 Please update Git: https://git-scm.com/downloads`)

package/lib/parseGitZOutput.js

@@ -6,6 +6,6 @@
 export const parseGitZOutput = (input) =>
   input
     ? input
-        .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
+        .replace(/\u0000$/, '') // oxlint-disable-line no-control-regex
         .split('\u0000')
     : []

package/lib/printTaskOutput.js

@@ -1,6 +1,6 @@
 /**
- * Handle logging of listr `ctx.output` to the specified `logger`
- * @param {Object} ctx - The listr initial state
+ * Handle logging of task `ctx.output` to the specified `logger`
+ * @param {Object} ctx - The context
  * @param {Object} logger - The logger
  */
 export const printTaskOutput = (ctx = {}, logger) => {

package/lib/runAll.js

@@ -2,29 +2,26 @@
 
 import path from 'node:path'
 
-import { Listr } from 'listr2'
-
 import { chunkFiles } from './chunkFiles.js'
 import { dim } from './colors.js'
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
+import * as figures from './figures.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'
 import { getStagedFiles } from './getStagedFiles.js'
 import { GitWorkflow } from './gitWorkflow.js'
 import { groupFilesByConfig } from './groupFilesByConfig.js'
 import {
-  DEPRECATED_GIT_ADD,
-  FAILED_GET_STAGED_FILES,
-  NO_STAGED_FILES,
-  NO_TASKS,
-  NOT_GIT_REPO,
-  SKIPPED_GIT_ERROR,
-  SKIPPING_HIDE_PARTIALLY_CHANGED,
+  deprecatedGitAdd,
+  failedGetStagedFiles,
+  noStagedFiles,
+  noTasks,
+  notGitRepo,
   skippingBackup,
+  skippingHidePartiallyChanged,
 } from './messages.js'
 import { normalizePath } from './normalizePath.js'
 import { resolveGitRepo } from './resolveGitRepo.js'
@@ -41,10 +38,24 @@ import {
   shouldRestoreUntrackedFiles,
   updateIndexSkipped,
 } from './state.js'
-import { ConfigNotFoundError, GetStagedFilesError, GitError, GitRepoError } from './symbols.js'
+import { ConfigNotFoundError, GetStagedFilesError, GitRepoError } from './symbols.js'
 
 const debugLog = createDebug('lint-staged:runAll')
 
+/**
+ * @param {Logger} logger
+ * @param {boolean} quiet
+ * @returns {Logger}
+ */
+const configureLogger = (logger, quiet) => {
+  if (quiet) {
+    const noop = () => {}
+    return { error: logger.error, log: noop, warn: noop }
+  }
+
+  return logger
+}
+
 /**
  * @param {ReturnType<typeof getInitialState>} ctx context
  * @param {unknown} cause error cause
@@ -57,13 +68,11 @@ const createError = (ctx, cause) =>
  *
  * @param {object} options
  * @param {boolean} [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.configObject] - Explicit config object from the js API
  * @param {string} [options.configPath] - Explicit path to a config file
  * @param {boolean} [options.continueOnError] - Run all tasks to completion even if one fails
  * @param {string} [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
@@ -81,13 +90,11 @@ const createError = (ctx, cause) =>
 export const runAll = async (
   {
     allowEmpty = false,
-    color = false,
     concurrent = true,
     configObject,
     configPath,
     continueOnError = false,
     cwd,
-    debug = false,
     diff,
     diffFilter,
     failOnChanges = false,
@@ -105,6 +112,8 @@ export const runAll = async (
   },
   logger = console
 ) => {
+  const thisLogger = configureLogger(logger, quiet)
+
   debugLog('Running all linter scripts...')
 
   // Resolve relative CWD option
@@ -123,7 +132,7 @@ export const runAll = async (
 
   const { topLevelDir, gitConfigDir } = await resolveGitRepo(cwd)
   if (!topLevelDir) {
-    if (!quiet) ctx.output.push(NOT_GIT_REPO)
+    if (!quiet) ctx.output.push(notGitRepo())
     ctx.errors.add(GitRepoError)
     throw createError(ctx, GitRepoError)
   }
@@ -137,22 +146,22 @@ export const runAll = async (
   // Lint-staged will create a backup stash only when there's an initial commit,
   // and when using the default list of staged files by default
   ctx.shouldBackup = hasInitialCommit && stash
-  if (!ctx.shouldBackup && !quiet) {
-    logger.warn(skippingBackup(hasInitialCommit, diff))
+  if (!ctx.shouldBackup) {
+    thisLogger.warn(skippingBackup(hasInitialCommit, diff))
   }
 
-  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !ctx.shouldHideAll && !quiet) {
-    logger.warn(SKIPPING_HIDE_PARTIALLY_CHANGED)
+  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !ctx.shouldHideAll) {
+    thisLogger.warn(skippingHidePartiallyChanged())
   }
 
   // Run staged files retrieval and config search in parallel since they're independent
   const [stagedFiles, foundConfigs] = await Promise.all([
     getStagedFiles({ cwd: topLevelDir, diff, diffFilter }),
-    searchConfigs({ configObject, configPath, cwd, topLevelDir }, logger),
+    searchConfigs({ configObject, configPath, cwd, topLevelDir }, thisLogger),
   ])
 
   if (!stagedFiles) {
-    if (!quiet) ctx.output.push(FAILED_GET_STAGED_FILES)
+    if (!quiet) ctx.output.push(failedGetStagedFiles())
     ctx.errors.add(GetStagedFilesError)
     throw createError(ctx, GetStagedFilesError)
   }
@@ -160,7 +169,7 @@ export const runAll = async (
 
   // If there are no files avoid executing any lint-staged logic
   if (stagedFiles.length === 0) {
-    if (!quiet) ctx.output.push(NO_STAGED_FILES)
+    if (!quiet) ctx.output.push(noStagedFiles())
     return ctx
   }
 
@@ -184,14 +193,7 @@ export const runAll = async (
   // Warn user when their command includes `git add`
   let hasDeprecatedGitAdd = false
 
-  const listrOptions = {
-    ctx,
-    exitOnError: false,
-    registerSignalListeners: false,
-    ...getRenderer({ color, debug, quiet }, logger),
-  }
-
-  const listrTasks = []
+  const tasks = []
 
   // Set of all staged files that matched a task glob. Values in a set are unique.
   /** @type {Set<import('./getStagedFiles.js').StagedFile>} */
@@ -215,13 +217,17 @@ export const runAll = async (
     }
 
     for (const [index, files] of stagedFileChunks.entries()) {
-      const chunkListrTasks = await Promise.all(
+      const taskChunk = await Promise.all(
         generateTasks({ config, cwd: groupCwd, files, relative }).map((task) =>
           (isFunctionTask(task.commands)
-            ? getFunctionTask(task.commands, task.fileList)
+            ? getFunctionTask({
+                abortController,
+                command: task.commands,
+                continueOnError,
+                files: task.fileList,
+              })
             : getSpawnedTasks({
                 abortController,
-                color,
                 commands: task.commands,
                 continueOnError,
                 cwd: groupCwd,
@@ -246,7 +252,7 @@ export const runAll = async (
             })
 
             hasDeprecatedGitAdd =
-              hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.command === 'git add')
+              hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.title.includes('git add'))
 
             const fileCount = task.fileList.length
 
@@ -254,17 +260,13 @@ export const runAll = async (
               title: `${task.pattern}${dim(
                 ` — ${fileCount} ${fileCount === 1 ? 'file' : 'files'}`
               )}`,
-              task: async (ctx, task) =>
-                task.newListr(
-                  subTasks,
-                  // Subtasks should not run in parallel, and should exit on error
-                  { concurrent: false, exitOnError: !continueOnError }
-                ),
+              task: subTasks,
               skip: () => {
                 // Skip task when no files matched
                 if (fileCount === 0) {
                   return `${task.pattern}${dim(' — no files')}`
                 }
+
                 return false
               },
             }
@@ -272,33 +274,29 @@ export const runAll = async (
         )
       )
 
-      listrTasks.push({
+      tasks.push({
         title:
           `${configName}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
           (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
-        task: (ctx, task) =>
-          task.newListr(chunkListrTasks, { concurrent, exitOnError: !continueOnError }),
+        task: taskChunk,
         skip: () => {
-          // Skip if the first step (backup) failed
-          if (ctx.errors.has(GitError)) return SKIPPED_GIT_ERROR
           // Skip chunk when no every task is skipped (due to no matches)
-          if (chunkListrTasks.every((task) => task.skip())) {
+          if (taskChunk.every((task) => task.skip())) {
             return `${configName}${dim(' — no tasks to run')}`
           }
+
           return false
         },
       })
     }
   }
 
-  if (hasDeprecatedGitAdd && !quiet) {
-    logger.warn(DEPRECATED_GIT_ADD)
+  if (hasDeprecatedGitAdd) {
+    thisLogger.warn(deprecatedGitAdd())
   }
 
-  // If all of the configured tasks should be skipped
-  // avoid executing any lint-staged logic
-  if (listrTasks.every((task) => task.skip())) {
-    if (!quiet) ctx.output.push(NO_TASKS)
+  if (tasks.every((task) => task.skip())) {
+    if (!quiet) ctx.output.push(noTasks())
     return ctx
   }
 
@@ -318,60 +316,62 @@ export const runAll = async (
     diffFilter,
     failOnChanges,
     gitConfigDir,
+    logger: thisLogger,
     matchedFileChunks,
     topLevelDir,
   })
 
-  const runner = new Listr(
-    [
-      {
-        title: ctx.shouldBackup ? 'Backing up original state...' : 'Preparing lint-staged...',
-        task: (ctx, task) => git.prepare(ctx, task),
-      },
-      {
-        title: 'Hiding unstaged changes to partially staged files...',
-        task: (ctx) => git.hidePartiallyStagedChanges(ctx),
-        enabled: shouldHidePartiallyStagedFiles,
-      },
-      {
-        title: `Running tasks for ${diff ? 'changed' : 'staged'} files...`,
-        task: (ctx, task) => git.runTasks(ctx, task, { listrTasks, concurrent }),
-        skip: () => listrTasks.every((task) => task.skip()),
-      },
-      {
-        title: 'Staging changes from tasks...',
-        task: (ctx) => git.updateIndex(ctx),
-        skip: updateIndexSkipped,
-      },
-      {
-        title: 'Restoring unstaged changes...',
-        task: (ctx) => git.restoreUnstagedChanges(ctx),
-        enabled: shouldRestoreUnstagedChanges,
-        skip: restoreUnstagedChangesSkipped,
-      },
-      {
-        title: 'Restoring untracked files...',
-        task: (ctx) => git.restoreUntrackedFiles(ctx),
-        enabled: shouldRestoreUntrackedFiles,
-        skip: restoreUnstagedChangesSkipped,
-      },
-      {
-        title: 'Reverting to original state because of errors...',
-        task: (ctx) => git.restoreOriginalState(ctx),
-        enabled: restoreOriginalStateEnabled,
-        skip: restoreOriginalStateSkipped,
-      },
-      {
-        title: 'Cleaning up temporary files...',
-        task: (ctx) => git.cleanup(ctx),
-        enabled: cleanupEnabled,
-        skip: cleanupSkipped,
-      },
-    ],
-    listrOptions
-  )
-
-  await runner.run()
+  await git.prepare(ctx)
+
+  if (shouldHidePartiallyStagedFiles(ctx)) {
+    await git.hidePartiallyStagedChanges(ctx)
+  }
+
+  if (abortController.signal.aborted || ctx.errors.size > 0) {
+    thisLogger.log(`${figures.cancelled()} ${dim(`Skipped running tasks…`)}`)
+  } else {
+    await git.runTasks(ctx, tasks, { abortController, concurrent })
+  }
+
+  if (updateIndexSkipped(ctx)) {
+    thisLogger.log(`${figures.cancelled()} ${dim('Skipped staging changes from tasks…')}`)
+  } else {
+    await git.updateIndex(ctx)
+  }
+
+  if (shouldRestoreUnstagedChanges(ctx)) {
+    if (restoreUnstagedChangesSkipped(ctx)) {
+      thisLogger.log(`${figures.cancelled()} ${dim('Skipped restoring unstaged changes…')}`)
+    } else {
+      await git.restoreUnstagedChanges(ctx)
+    }
+  }
+
+  if (shouldRestoreUntrackedFiles(ctx)) {
+    if (restoreUnstagedChangesSkipped(ctx)) {
+      thisLogger.log(`${figures.cancelled()} ${dim('Skipped restoring untracked files…')}`)
+    } else {
+      await git.restoreUntrackedFiles(ctx)
+    }
+  }
+
+  if (restoreOriginalStateEnabled(ctx)) {
+    if (restoreOriginalStateSkipped(ctx)) {
+      thisLogger.log(
+        `${figures.cancelled()} ${dim('Skipped reverting to original state because of errors…')}`
+      )
+    } else {
+      await git.restoreOriginalState(ctx)
+    }
+  }
+
+  if (cleanupEnabled(ctx)) {
+    if (cleanupSkipped(ctx)) {
+      thisLogger.log(`${figures.cancelled()} ${dim('Skipped cleaning up temporary files…')}`)
+    } else {
+      await git.cleanup(ctx)
+    }
+  }
 
   if (ctx.errors.size > 0) {
     throw createError(ctx)

package/lib/runParallelTasks.js

@@ -0,0 +1,112 @@
+import * as colors from './colors.js'
+import { createDebug } from './debug.js'
+import * as figures from './figures.js'
+
+const debugLog = createDebug('lint-staged:runParallelTasks')
+
+/** @param {Number | boolean} options.concurrent Boolean value for whether to run concurrently */
+export const parseConcurrency = (concurrent) => {
+  if (concurrent === true || concurrent === Infinity) {
+    return Infinity
+  }
+
+  if (concurrent === false || concurrent < 1 || !Number.isInteger(concurrent)) {
+    return 1
+  }
+
+  return concurrent
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Array} tasks
+ * @param {Object} options
+ * @param {AbortController} abortController
+ * @param {Number | boolean} [options.concurrent=true] Boolean value for whether to run concurrently,
+ * or a number value controls the number of concurrent executions
+ */
+export const runParallelTasks = async (
+  ctx,
+  tasks,
+  { abortController, concurrent = true, logger }
+) => {
+  const concurrency = parseConcurrency(concurrent)
+
+  debugLog('Running parallel tasks with concurrency:', concurrency)
+
+  const indent = tasks.length > 1 ? '    ' : '  '
+  const allPerGlobTasks = []
+
+  // the array of actual tasks is split per config and per glob
+  for (const perConfig of tasks) {
+    if (perConfig.skip()) {
+      debugLog('Skipped configuration:', perConfig.title)
+    } else {
+      debugLog('Running configuration:', perConfig.title)
+
+      if (tasks.length > 1) {
+        // display name of config only when there are multiple
+        logger?.log(colors.dim(`${indent}${perConfig.title}`))
+      }
+    }
+
+    for (const perGlob of perConfig.task) {
+      if (perGlob.skip()) {
+        debugLog('Skipped glob from configuration:', perConfig.title, perGlob.title)
+        continue
+      }
+
+      if (perConfig.skip()) {
+        continue // entire group is skipped, but debug logs still show above
+      }
+
+      debugLog('Running glob:', perGlob.title)
+      logger?.log(colors.dim(`${indent}  ${perGlob.title}`))
+
+      for (const task of perGlob.task) {
+        debugLog('Running task:', task.title)
+        logger?.log(colors.dim(`${indent}    ${figures.wip()} ${task.title}`))
+      }
+      // per-glob tasks run serially
+      allPerGlobTasks.push(perGlob.task)
+    }
+  }
+
+  logger?.log('') // empty line before all tasks
+
+  const runSequential = async (tasks) => {
+    for (const { title, task } of tasks) {
+      if (abortController.signal.aborted) {
+        debugLog('Skipped task because aborted:', title)
+        // Log all aborted tasks without actually running them
+        logger?.warn(`${figures.cancelled()} ${title}`)
+        continue
+      }
+
+      try {
+        debugLog('Running task:', title)
+        await task(ctx)
+        debugLog('Done running task:', title)
+        logger?.log(`${figures.done()} ${title}`)
+      } catch {
+        debugLog('Failed to run task:', title)
+        logger?.error(colors.red(`${figures.error()} ${title}`))
+      }
+    }
+  }
+
+  let next = 0
+  const worker = async () => {
+    while (next < allPerGlobTasks.length) {
+      const perGlobTasks = allPerGlobTasks[next++]
+      await runSequential(perGlobTasks)
+    }
+  }
+
+  const length = Math.min(allPerGlobTasks.length, concurrency)
+  debugLog('Running workers with concurrency:', length)
+  await Promise.all(Array.from({ length }, worker))
+  debugLog('Done running workers')
+
+  logger?.log('') // empty line after all tasks
+}