lint-staged 17.1.1 → 17.2.0

package/lib/generateTasks.js

@@ -16,7 +16,7 @@ const debugLog = createDebug('lint-staged:generateTasks')
  * @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')
+  debugLog('Generating tasks')
 
   /** @type {StagedFile[]} */
   const relativeFiles = files.map((file) => ({

package/lib/getSpawnedTask.js

@@ -57,16 +57,16 @@ export const createTaskError = (command, result, ctx, signal = 'FAILED') => {
 }
 
 /**
- * Returns the task function for the linter.
+ * Returns the spawnable task.
  *
  * @param {Object} options
  * @param {AbortController} options.abortController
- * @param {string} options.command — Linter task
+ * @param {string} options.command — the command to spawn
  * @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.isFn - Whether the task is a function instead of a string
+ * @param {string[]} options.files — Filepaths to run the task against
  * @param {Boolean} [options.verbose] — Always show task verbose
  * @returns {() => Promise<Array<string>>}
  */

package/lib/getSpawnedTasks.js

@@ -4,6 +4,104 @@ import { configurationError } from './messages.js'
 
 const debugLog = createDebug('lint-staged:getSpawnedTasks')
 
+/**
+ * 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
+ */
+export const getMaxArgLength = (platform = process.platform) => {
+  switch (platform) {
+    case 'darwin':
+      return 262_144
+    case 'win32':
+      return 8_191
+    default:
+      return 131_072
+  }
+}
+
+/**
+ * Chunk `files` so that when joined with `command`, the resulting string fits into `maxArgLength`.
+ * For function commands, they are evaluated with the list of files and measured afterwards.
+ *
+ * @param {string | Function} command
+ * @param {string[]} files
+ * @param {number} [maxArgLength]
+ * @returns {Promise<Array<{ command: string, files: string[] }>>}
+ */
+export const chunkFilesForCommand = async (command, files, maxArgLength) => {
+  const isFn = typeof command === 'function'
+  const resolved = isFn ? await command([...files]) : command
+  const resolvedCommands = Array.isArray(resolved) ? resolved : [resolved]
+
+  if (isFn && resolvedCommands.some((command) => typeof command !== 'string')) {
+    throw new Error(
+      configurationError(
+        '[Function]',
+        'Function task should return a string or an array of strings',
+        resolved
+      )
+    )
+  }
+
+  if (!maxArgLength || maxArgLength === Infinity || files.length <= 1) {
+    debugLog(
+      'Skipping chunking because maxArgLength is %s and there are %s files',
+      maxArgLength,
+      files.length
+    )
+
+    return resolvedCommands.map((resolvedCommand) => ({
+      command: resolvedCommand,
+      files,
+    }))
+  }
+
+  const fits = resolvedCommands.every((resolvedCommand) => {
+    /**
+     * Really the command is spawned using `tinyexec` and the files passed as an array of
+     * arguments; but this approximates the length without quoting filenames.
+     */
+    const finalCommandString = isFn ? resolvedCommand : resolvedCommand + ' ' + files.join(' ')
+
+    debugLog(
+      'Resolved an argument string length of %d characters from %d files',
+      finalCommandString.length,
+      files.length
+    )
+
+    return finalCommandString.length <= maxArgLength
+  })
+
+  if (fits) {
+    return resolvedCommands.map((resolvedCommand) => ({
+      command: resolvedCommand,
+      files,
+    }))
+  }
+
+  const middle = Math.ceil(files.length / 2)
+  const left = files.slice(0, middle)
+  const right = files.slice(middle)
+
+  debugLog(
+    'Splitting %d files into chunks of %d and %d for maxArgLength of %d',
+    files.length,
+    left.length,
+    right.length,
+    maxArgLength
+  )
+
+  const commands = await Promise.all([
+    chunkFilesForCommand(command, left, maxArgLength),
+    chunkFilesForCommand(command, right, maxArgLength),
+  ])
+
+  return commands.flat()
+}
+
 /**
  * Creates and returns an array of tasks which map to the given commands.
  *
@@ -13,6 +111,7 @@ const debugLog = createDebug('lint-staged:getSpawnedTasks')
  * @param {string} options.continueOnError
  * @param {string} options.cwd
  * @param {import('./getStagedFiles.js').StagedFile[]} options.files
+ * @param {number} [options.maxArgLength]
  * @param {string} options.topLevelDir
  * @param {Boolean} verbose
  */
@@ -22,52 +121,41 @@ export const getSpawnedTasks = async ({
   continueOnError,
   cwd,
   files,
+  maxArgLength,
   topLevelDir,
   verbose,
 }) => {
   debugLog('Creating 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,
-        command,
-        continueOnError,
-        cwd,
-        files: filepaths,
-        topLevelDir,
-        isFn,
-        verbose,
-      })
-
-      cmdTasks.push({ title: command, task })
-    }
+  if (filepaths.length === 0) {
+    debugLog('Skipping task generation because no files matched', { commands })
+    return []
   }
 
-  return cmdTasks
+  const spawnedTasks = await Promise.all(
+    commandArray.map(async (cmd) => {
+      const isFn = typeof cmd === 'function'
+      const chunkedCommands = await chunkFilesForCommand(cmd, filepaths, maxArgLength)
+
+      return chunkedCommands.map(({ command, files: chunkedFiles }) => ({
+        title: command,
+        task: getSpawnedTask({
+          abortController,
+          command,
+          continueOnError,
+          cwd,
+          files: chunkedFiles,
+          topLevelDir,
+          isFn,
+          verbose,
+        }),
+      }))
+    })
+  )
+
+  return spawnedTasks.flat()
 }

package/lib/gitWorkflow.js

@@ -8,6 +8,7 @@ import { execGit } from './execGit.js'
 import * as figures from './figures.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
+import { chunkFilesForCommand } from './getSpawnedTasks.js'
 import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import { runParallelTasks } from './runParallelTasks.js'
@@ -86,7 +87,8 @@ export class GitWorkflow {
     failOnChanges,
     gitConfigDir,
     logger,
-    matchedFileChunks,
+    matchedFiles,
+    maxArgLength,
     topLevelDir,
   }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: topLevelDir })
@@ -96,8 +98,9 @@ export class GitWorkflow {
     this.gitConfigDir = gitConfigDir
     this.failOnChanges = !!failOnChanges
     this.logger = logger
-    /** @type {import('./getStagedFiles.js').StagedFile[][]} */
-    this.matchedFileChunks = matchedFileChunks
+    /** @type {Set<import('./getStagedFiles.js').StagedFile>} */
+    this.matchedFiles = matchedFiles
+    this.maxArgLength = maxArgLength
     this.topLevelDir = topLevelDir
 
     /**
@@ -369,25 +372,27 @@ export class GitWorkflow {
         ? normalizePath(process.env.GIT_INDEX_FILE)
         : process.env.GIT_INDEX_FILE
 
-      /** Needs to be run serially because of locking Git operation */
-      for (const files of this.matchedFileChunks) {
-        const accessCheckedFiles = await Promise.allSettled(
-          files.map(async (f) => {
-            if (f.status === 'D') {
-              await fs.access(f.filepath)
-              return f.filepath // File is no longer deleted and can be added
-            } else {
-              return f.filepath
-            }
-          })
-        )
+      const accessCheckedFiles = await Promise.allSettled(
+        Array.from(this.matchedFiles).map(async (f) => {
+          if (f.status === 'D') {
+            await fs.access(f.filepath)
+            return f.filepath // File is no longer deleted and can be added
+          } else {
+            return f.filepath
+          }
+        })
+      )
 
-        const addableFiles = accessCheckedFiles.flatMap((r) =>
-          r.status === 'fulfilled' ? [r.value] : []
-        )
+      const addableFiles = accessCheckedFiles.flatMap((r) =>
+        r.status === 'fulfilled' ? [r.value] : []
+      )
 
+      const addCommands = await chunkFilesForCommand('git add --', addableFiles, this.maxArgLength)
+
+      /** Needs to be run serially because of locking Git operation */
+      for (const { files } of addCommands) {
         debugLog('Updating active Git index: %s', activeIndexFile)
-        await this.execGit(['add', '--', ...addableFiles])
+        await this.execGit(['add', '--', ...files])
         debugLog('Done updating Git index: %s', activeIndexFile)
 
         if (activeIndexFile?.endsWith('.lock')) {
@@ -402,7 +407,7 @@ export class GitWorkflow {
            */
           if (activeIndexFile !== defaultIndexLock) {
             debugLog('Updating default Git index again: %s', defaultIndexLock)
-            await this.execGit(['add', '--', ...addableFiles], {
+            await this.execGit(['add', '--', ...files], {
               env: {
                 GIT_INDEX_FILE: defaultIndexLock,
               },

package/lib/index.js

@@ -2,6 +2,7 @@ import { assertGitVersion, MIN_GIT_VERSION } from './assertGitVersion.js'
 import { enableColors } from './colors.js'
 import { createDebug, enableDebug } from './debug.js'
 import { execGit } from './execGit.js'
+import { getMaxArgLength } from './getSpawnedTasks.js'
 import {
   gitError,
   minGitVersionRequired,
@@ -27,25 +28,6 @@ import { getVersion } from './version.js'
 
 const debugLog = createDebug('lint-staged')
 
-/**
- * Get the maximum length of a command-line argument string based on current platform,
- * roughly half of the real maximum length
- *
- * 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': // 262_144
-      return 131_072
-    case 'win32': // 8_191
-      return 4_096
-    default: // 131_072
-      return 65_536
-  }
-}
-
 /**
  * @typedef {(...any) => void} LogFunction
  * @typedef {{ error: LogFunction, log: LogFunction, warn: LogFunction }} Logger

package/lib/runAll.js

@@ -2,7 +2,6 @@
 
 import path from 'node:path'
 
-import { chunkFiles } from './chunkFiles.js'
 import { dim } from './colors.js'
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
@@ -114,7 +113,7 @@ export const runAll = async (
 ) => {
   const thisLogger = configureLogger(logger, quiet)
 
-  debugLog('Running all linter scripts...')
+  debugLog('Running all tasks...')
 
   // Resolve relative CWD option
   const hasExplicitCwd = !!cwd
@@ -204,91 +203,79 @@ export const runAll = async (
   for (const [configPath, { config, files }] of Object.entries(filesByConfig)) {
     const configName = configPath ? normalizePath(path.relative(cwd, configPath)) : 'Config object'
 
-    const stagedFileChunks = chunkFiles({ baseDir: topLevelDir, files, maxArgLength, relative })
-
     // Use actual cwd if it's specified, or there's only a single config file.
     // Otherwise use the directory of the config file for each config group,
     // to make sure tasks are separated from each other.
     const groupCwd = hasExplicitCwd || !hasMultipleConfigs ? cwd : path.dirname(configPath)
 
-    const chunkCount = stagedFileChunks.length
-    if (chunkCount > 1) {
-      debugLog('Chunked staged files from `%s` into %d part', configPath, chunkCount)
-    }
-
-    for (const [index, files] of stagedFileChunks.entries()) {
-      const taskChunk = await Promise.all(
-        generateTasks({ config, cwd: groupCwd, files, relative }).map((task) =>
-          (isFunctionTask(task.commands)
-            ? getFunctionTask({
-                abortController,
-                command: task.commands,
-                continueOnError,
-                files: task.fileList,
-              })
-            : getSpawnedTasks({
-                abortController,
-                commands: task.commands,
-                continueOnError,
-                cwd: groupCwd,
-                files: task.fileList,
-                topLevelDir,
-                verbose,
-              })
-          ).then((subTasks) => {
-            // Add files from task to match set
-            task.fileList.forEach((file) => {
-              // Make sure relative files are normalized to the
-              // group cwd, because other there might be identical
-              // relative filenames in the entire set.
-              const normalizedFile = path.isAbsolute(file.filepath)
-                ? file
-                : {
-                    filepath: normalizePath(path.join(groupCwd, file.filepath)),
-                    status: file.status,
-                  }
-
-              matchedFiles.add(normalizedFile)
+    const configTasks = await Promise.all(
+      generateTasks({ config, cwd: groupCwd, files, relative }).map((task) =>
+        (isFunctionTask(task.commands)
+          ? getFunctionTask({
+              abortController,
+              command: task.commands,
+              continueOnError,
+              files: task.fileList,
+            })
+          : getSpawnedTasks({
+              abortController,
+              commands: task.commands,
+              continueOnError,
+              cwd: groupCwd,
+              files: task.fileList,
+              maxArgLength,
+              topLevelDir,
+              verbose,
             })
+        ).then((subTasks) => {
+          // Add files from task to match set
+          task.fileList.forEach((file) => {
+            // Make sure relative files are normalized to the
+            // group cwd, because other there might be identical
+            // relative filenames in the entire set.
+            const normalizedFile = path.isAbsolute(file.filepath)
+              ? file
+              : {
+                  filepath: normalizePath(path.join(groupCwd, file.filepath)),
+                  status: file.status,
+                }
 
-            hasDeprecatedGitAdd =
-              hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.title.includes('git add'))
+            matchedFiles.add(normalizedFile)
+          })
 
-            const fileCount = task.fileList.length
+          hasDeprecatedGitAdd =
+            hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.title.includes('git add'))
 
-            return {
-              title: `${task.pattern}${dim(
-                ` — ${fileCount} ${fileCount === 1 ? 'file' : 'files'}`
-              )}`,
-              task: subTasks,
-              skip: () => {
-                // Skip task when no files matched
-                if (fileCount === 0) {
-                  return `${task.pattern}${dim(' — no files')}`
-                }
+          const fileCount = task.fileList.length
 
-                return false
-              },
-            }
-          })
-        )
-      )
+          return {
+            title: `${task.pattern}${dim(` — ${fileCount} ${fileCount === 1 ? 'file' : 'files'}`)}`,
+            task: subTasks,
+            skip: () => {
+              // Skip task when no files matched
+              if (fileCount === 0) {
+                return `${task.pattern}${dim(' — no files')}`
+              }
 
-      tasks.push({
-        title:
-          `${configName}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
-          (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
-        task: taskChunk,
-        skip: () => {
-          // Skip chunk when no every task is skipped (due to no matches)
-          if (taskChunk.every((task) => task.skip())) {
-            return `${configName}${dim(' — no tasks to run')}`
+              return false
+            },
           }
-
-          return false
-        },
-      })
-    }
+        })
+      )
+    )
+
+    tasks.push({
+      title: `${configName}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}`,
+      task: configTasks,
+      skip: () => {
+        // Skip chunk when no every task is skipped (due to no matches)
+        if (configTasks.every((task) => task.skip())) {
+          return `${configName}${dim(' — no tasks to run')}`
+        }
+
+        return false
+      },
+    })
   }
 
   if (hasDeprecatedGitAdd) {
@@ -300,16 +287,6 @@ export const runAll = async (
     return ctx
   }
 
-  // Chunk matched files for better Windows compatibility
-  /** @type {import('./getStagedFiles.js').StagedFile[][]} */
-  const matchedFileChunks = chunkFiles({
-    // matched files are relative to `cwd`, not `topLevelDir`, when `relative` is used
-    baseDir: cwd,
-    files: Array.from(matchedFiles),
-    maxArgLength,
-    relative: false,
-  })
-
   const git = new GitWorkflow({
     allowEmpty,
     diff,
@@ -317,7 +294,8 @@ export const runAll = async (
     failOnChanges,
     gitConfigDir,
     logger: thisLogger,
-    matchedFileChunks,
+    matchedFiles,
+    maxArgLength,
     topLevelDir,
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "17.1.1",
+  "version": "17.2.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {
@@ -69,8 +69,8 @@
     "cross-env": "10.1.0",
     "husky": "9.1.7",
     "mock-stdin": "1.0.0",
-    "oxfmt": "0.59.0",
-    "oxlint": "1.74.0",
+    "oxfmt": "0.60.0",
+    "oxlint": "1.75.0",
     "semver": "7.8.5",
     "vitest": "4.1.10"
   },

package/lib/chunkFiles.js

@@ -1,65 +0,0 @@
-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 || maxArgLength === Infinity) {
-    debugLog(`Skip chunking files because of maxArgLength is ${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)
-}