lint-staged 17.1.0 → 17.1.1

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

@@ -46,8 +46,8 @@ export const chunkFiles = ({ files, baseDir, maxArgLength = null, relative = fal
     }
   })
 
-  if (!maxArgLength) {
-    debugLog('Skip chunking files because of undefined maxArgLength')
+  if (!maxArgLength || maxArgLength === Infinity) {
+    debugLog(`Skip chunking files because of maxArgLength is ${maxArgLength}`)
     return [normalizedFiles] // wrap in an array to return a single chunk
   }
 

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

@@ -28,7 +28,8 @@ import { getVersion } from './version.js'
 const debugLog = createDebug('lint-staged')
 
 /**
- * Get the maximum length of a command-line argument string based on current platform
+ * 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
@@ -36,12 +37,12 @@ const debugLog = createDebug('lint-staged')
  */
 const getMaxArgLength = () => {
   switch (process.platform) {
-    case 'darwin':
-      return 262144
-    case 'win32':
-      return 8191
-    default:
-      return 131072
+    case 'darwin': // 262_144
+      return 131_072
+    case 'win32': // 8_191
+      return 4_096
+    default: // 131_072
+      return 65_536
   }
 }
 
@@ -91,7 +92,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/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.1.1",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {