lint-staged 17.1.0 → 17.2.0

package/README.md

@@ -1,9 +1,5 @@
 # 🚫💩 lint-staged
 
-[![npm version](https://badge.fury.io/js/lint-staged.svg)](https://badge.fury.io/js/lint-staged)
-
----
-
 Run tasks like formatters and linters against staged git files and don't let :poop: slip into your code base!
 
 ```bash
@@ -168,7 +164,7 @@ By default changes made by tasks are automatically staged and added to the commi
 
 #### `--max-arg-length [number]`
 
-long commands (a lot of files) are automatically split into multiple chunks when it detects the current shell cannot handle them. Use this flag to override the maximum length of the generated command string.
+The list of staged files are appended to configured tasks as arguments, and the resulting string might be too long for the current shell, especially on Windows. _Lint-staged_ tries to avoid this by splitting the list of staged files into chunks resulting in the commands being run multiple times. This behavior affects all tasks, including functions. Use the `--max-arg-length` to override the platform-specific default value if you want to avoid this. Setting `--max-arg-length=Infinity` will disable chunking completely.
 
 #### `--no-stash`
 

package/lib/cli.js

@@ -91,7 +91,7 @@ const CLI_OPTIONS = [
   },
   {
     flag: 'max-arg-length',
-    type: 'string', // Parsed with `parseInt()` below
+    type: 'string', // Parsed with `Number()` below
     positional: '[number]',
     description: 'maximum length of the command-line argument string (default: 0)',
   },
@@ -128,6 +128,20 @@ const CLI_OPTIONS = [
   },
 ]
 
+/** @type {(value: string |undefined) => number | boolean | null | undefined} */
+const parseBoolOrNumber = (value) => {
+  switch (value) {
+    case undefined:
+      return undefined
+    case 'true':
+      return true
+    case 'false':
+      return false
+    default:
+      return Number(value)
+  }
+}
+
 /** @param {string[]} argv */
 export const parseCliOptions = (argv) => {
   const options = CLI_OPTIONS.reduce((acc, current) => {
@@ -167,18 +181,9 @@ export const parseCliOptions = (argv) => {
     values['hide-unstaged'] = false // becomes redundant
   }
 
-  const maxArgLength =
-    values['max-arg-length'] !== undefined ? parseInt(values['max-arg-length'], 10) : undefined
-
-  if (Number.isNaN(maxArgLength)) {
-    throw new TypeError(`Option '--mar-arg-length' takes a numeric argument`, {
-      cause: { '--max-arg-length': values['max-arg-length'] },
-    })
-  }
-
   return {
     allowEmpty: values['allow-empty'] ?? false,
-    concurrent: values.concurrent === undefined ? true : JSON.parse(values.concurrent),
+    concurrent: parseBoolOrNumber(values.concurrent) ?? true,
     configPath: values.config,
     continueOnError: !!values['continue-on-error'],
     cwd: values.cwd,
@@ -190,7 +195,7 @@ export const parseCliOptions = (argv) => {
     hidePartiallyStaged: values['hide-partially-staged'] ?? true,
     hideUnstaged: !!values['hide-unstaged'],
     hideAll: !!values['hide-all'],
-    maxArgLength,
+    maxArgLength: parseBoolOrNumber(values['max-arg-length']),
     quiet: !!values.quiet,
     relative: !!values.relative,
     revert: values.revert ?? true,

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,24 +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
- *
- * 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
@@ -91,7 +74,7 @@ const lintStaged = async (
     hideAll = false,
     hideUnstaged = false,
     hidePartiallyStaged = !(hideAll || hideUnstaged),
-    maxArgLength = getMaxArgLength() / 2,
+    maxArgLength = getMaxArgLength(),
     quiet = false,
     relative = false,
     // Stashing should be disabled by default when the `diff` option is used

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/lib/runParallelTasks.js

@@ -6,15 +6,15 @@ const debugLog = createDebug('lint-staged:runParallelTasks')
 
 /** @param {Number | boolean} options.concurrent Boolean value for whether to run concurrently */
 export const parseConcurrency = (concurrent) => {
-  if (concurrent === false || concurrent < 1 || Number.isNaN(concurrent)) {
-    return 1
+  if (concurrent === true || concurrent === Infinity) {
+    return Infinity
   }
 
-  if (concurrent === true) {
-    return Infinity
+  if (concurrent === false || concurrent < 1 || !Number.isInteger(concurrent)) {
+    return 1
   }
 
-  return parseInt(concurrent)
+  return concurrent
 }
 
 /**

package/lib/validateOptions.js

@@ -8,6 +8,9 @@ import { InvalidOptionsError } from './symbols.js'
 
 const debugLog = createDebug('lint-staged:validateOptions')
 
+/** @type {(value: number) => boolean} */
+const isValidIntegerValue = (value) => Number.isInteger(value) || value === Infinity
+
 /**
  * Validate lint-staged options, either from the Node.js API or the command line flags.
  * @param {*} options
@@ -17,26 +20,41 @@ const debugLog = createDebug('lint-staged:validateOptions')
 export const validateOptions = async (options = {}, logger) => {
   debugLog('Validating options...')
 
+  const { concurrent, cwd, maxArgLength } = options
+
   if (
-    options.concurrent !== undefined &&
-    typeof options.concurrent !== 'boolean' &&
-    (!Number.isInteger(options.concurrent) || Number.isNaN(options.concurrent))
+    concurrent !== undefined &&
+    typeof concurrent !== 'boolean' &&
+    (!isValidIntegerValue(concurrent) || concurrent < 1)
   ) {
-    logger.error(invalidOption('concurrent', `${options.concurrent}`, 'Must be boolean or integer'))
+    logger.error(
+      invalidOption('concurrent', `${concurrent}`, 'Must be boolean, positive integer or Infinite')
+    )
     throw InvalidOptionsError
   }
 
   /** Ensure the passed cwd option exists; it might also be relative */
-  if (typeof options.cwd === 'string') {
+  if (typeof cwd === 'string') {
     try {
-      const resolved = path.resolve(options.cwd)
+      const resolved = path.resolve(cwd)
       await fs.access(resolved, constants.F_OK)
     } catch (error) {
       debugLog('Failed to validate options: %o', options)
-      logger.error(invalidOption('cwd', options.cwd, error.message))
+      logger.error(invalidOption('cwd', cwd, error.message))
       throw InvalidOptionsError
     }
   }
 
+  if (
+    maxArgLength !== undefined &&
+    maxArgLength !== null &&
+    (!isValidIntegerValue(maxArgLength) || maxArgLength < 1)
+  ) {
+    logger.error(
+      invalidOption('maxArgLength', `${maxArgLength}`, 'Must be positive integer, or Infinite')
+    )
+    throw InvalidOptionsError
+  }
+
   debugLog('Validated options: %o', options)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "17.1.0",
+  "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) {
-    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)
-}