lint-staged 16.2.0 → 16.2.2

package/README.md

@@ -127,9 +127,9 @@ Options:
 
 Any lost modifications can be restored from a git stash:
 
-  > git stash list
-  stash@{0}: automatic lint-staged backup
-  > git stash apply --index stash@{0}
+  > git stash list --format="%h %s"
+  h0a0s0h0 On main: lint-staged automatic backup
+  > git apply --index h0a0s0h0
 ```
 
 #### `--allow-empty`

package/bin/lint-staged.js

@@ -6,7 +6,7 @@ import { Option, program } from 'commander'
 
 import { createDebug, enableDebug } from '../lib/debug.js'
 import lintStaged from '../lib/index.js'
-import { CONFIG_STDIN_ERROR, RESTORE_STASH_EXAMPLE } from '../lib/messages.js'
+import { CONFIG_STDIN_ERROR, restoreStashExample } from '../lib/messages.js'
 import { readStdin } from '../lib/readStdin.js'
 import { getVersion } from '../lib/version.js'
 
@@ -108,7 +108,7 @@ program
   .addOption(
     new Option('--hide-unstaged', 'hide all unstaged changes, instead of just partially staged')
       .default(false)
-      .implies({ hidePartiallyStaged: true })
+      .implies({ hidePartiallyStaged: false })
   )
 
   .addOption(new Option('-q, --quiet', 'disable lint-staged’s own console output').default(false))
@@ -120,7 +120,7 @@ program
     ).default(false)
   )
 
-  .addHelpText('afterAll', '\n' + RESTORE_STASH_EXAMPLE)
+  .addHelpText('afterAll', '\n' + restoreStashExample())
 
 const cliOptions = program.parse(process.argv).opts()
 

package/lib/gitWorkflow.js

@@ -6,9 +6,10 @@ import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
+import { parseGitZOutput } from './parseGitZOutput.js'
 import {
   ApplyEmptyCommitError,
-  ExitCodeError,
+  FailOnChangesError,
   GetBackupStashError,
   GitError,
   HideUnstagedChangesError,
@@ -69,6 +70,12 @@ const handleError = (error, ctx, symbol) => {
 
 const calculateSha256 = (input) => crypto.createHash('sha256').update(input, 'utf-8').digest('hex')
 
+/**
+ * The lines are wrapped in double quotes
+ * @returns {string[]}
+ */
+const cleanGitStashOutput = (lines) => lines.map((line) => line.replace(/^"(.*)"$/, '$1'))
+
 export class GitWorkflow {
   /**
    * @param {Object} opts
@@ -115,11 +122,12 @@ export class GitWorkflow {
    * Get name of backup stash
    */
   async getBackupStash(ctx) {
-    const stashes = await this.execGit(['stash', 'list'])
+    /** Print stash list with short hash and subject */
+    const stashes = await this.execGit(['stash', 'list', '--format="%h %s"', '-z'])
+      .then(parseGitZOutput)
+      .then(cleanGitStashOutput)
 
-    const index = stashes
-      .split('\n')
-      .findIndex((line) => line.includes(STASH) && line.includes(ctx.backupHash))
+    const index = stashes.findIndex((line) => line.startsWith(ctx.backupHash))
 
     if (index === -1) {
       ctx.errors.add(GetBackupStashError)
@@ -231,20 +239,40 @@ export class GitWorkflow {
         // - in git versions =< 2.13.0 the `git stash --keep-index` option resurrects deleted files
         // - git stash can't infer RD or MD states correctly, and will lose the deletion
         this.deletedFiles = await this.getDeletedFiles()
+      }
 
-        // Save stash of all staged files.
-        // The `stash create` command creates a dangling commit without removing any files,
-        // and `stash store` saves it as an actual stash.
-        const stashHash = await this.execGit(['stash', 'create'])
-        ctx.backupHash = await this.execGit(['rev-parse', '--short', stashHash])
-        await this.execGit([
-          'stash',
-          'store',
-          '--quiet',
-          '--message',
-          `${STASH} (${ctx.backupHash})`,
-          ctx.backupHash,
-        ])
+      if (ctx.shouldHideUnstaged) {
+        this.unstagedFiles = await this.getUnstagedFiles({ onlyPartial: false })
+        ctx.hasFilesToHide = !!this.unstagedFiles
+      } else if (ctx.shouldHidePartiallyStaged) {
+        this.unstagedFiles = await this.getUnstagedFiles({ onlyPartial: true })
+        ctx.hasFilesToHide = !!this.unstagedFiles
+      }
+
+      if (this.unstagedFiles) {
+        const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
+        ctx.unstagedPatch = unstagedPatch
+        const files = processRenames(this.unstagedFiles)
+        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
+      }
+
+      if (ctx.shouldBackup) {
+        if (ctx.shouldHideUnstaged) {
+          /** Save stash of all changes, clearing the working tree but keeping staged files as-is */
+          await this.execGit(['stash', 'push', '--keep-index', '--message', STASH])
+          /** Print stash list with short hash and subject */
+          const stashes = await this.execGit(['stash', 'list', '--format="%h %s"', '-z'])
+            .then(parseGitZOutput)
+            .then(cleanGitStashOutput)
+
+          /** The stash line starts with the short hash, so we split from space and choose the first part */
+          ctx.backupHash = stashes.find((line) => line.includes(STASH))?.split(' ')[0]
+        } else {
+          /** Save stash of all changes, keeping all files as-is */
+          const stashHash = await this.execGit(['stash', 'create'])
+          ctx.backupHash = await this.execGit(['rev-parse', '--short', stashHash])
+          await this.execGit(['stash', 'store', '--quiet', '--message', STASH, ctx.backupHash])
+        }
 
         task.title = `Backed up original state in git stash (${ctx.backupHash})`
         debugLog(task.title)
@@ -258,32 +286,12 @@ export class GitWorkflow {
         this.unstagedDiffSha256 = calculateSha256(diff)
         debugLog('SHA-256 hash of unstaged changes is %S', this.unstagedDiffSha256)
       }
-
-      if (ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) {
-        // Unstaged changes to these files should be hidden before the tasks run.
-        this.unstagedFiles = await this.getUnstagedFiles({
-          onlyPartial: ctx.shouldHideUnstaged ? false : ctx.shouldHidePartiallyStaged,
-        })
-
-        if (this.unstagedFiles) {
-          ctx.hasFilesToHide = true
-          const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-          ctx.unstagedPatch = unstagedPatch
-          const files = processRenames(this.unstagedFiles)
-          await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
-        } else {
-          ctx.hasFilesToHide = false
-        }
-      }
     } catch (error) {
       handleError(error, ctx)
     }
   }
 
-  /**
-   * Remove unstaged changes to all partially staged files, to avoid tasks from seeing them
-   */
-  async hideUnstagedChanges(ctx) {
+  async hidePartiallyStagedChanges(ctx) {
     try {
       const files = processRenames(this.unstagedFiles, false)
       await this.execGit(['checkout', '--force', '--', ...files])
@@ -309,7 +317,7 @@ export class GitWorkflow {
       const diffSha256 = calculateSha256(diff)
       debugLog('SHA-256 hash of changes after tasks is %S', this.diffSha256)
       if (this.unstagedDiffSha256 !== diffSha256) {
-        ctx.errors.add(ExitCodeError)
+        ctx.errors.add(FailOnChangesError)
         throw new Error('Tasks modified files and --fail-on-changes was used!')
       }
     }
@@ -368,8 +376,8 @@ export class GitWorkflow {
       debugLog('Error while restoring changes:')
       debugLog(applyError)
       debugLog('Retrying with 3-way merge')
+      // Retry with a 3-way merge if normal apply fails
       try {
-        // Retry with a 3-way merge if normal apply fails
         await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', unstagedPatch])
       } catch (threeWayApplyError) {
         debugLog('Error while restoring unstaged changes using 3-way merge:')

package/lib/index.d.ts

@@ -1,12 +1,12 @@
-type SyncGenerateTask = (stagedFileNames: string[]) => string | string[]
+type SyncGenerateTask = (stagedFileNames: readonly string[]) => string | string[]
 
-type AsyncGenerateTask = (stagedFileNames: string[]) => Promise<string | string[]>
+type AsyncGenerateTask = (stagedFileNames: readonly string[]) => Promise<string | string[]>
 
 type GenerateTask = SyncGenerateTask | AsyncGenerateTask
 
 type TaskFunction = {
   title: string
-  task: (stagedFileNames: string[]) => void | Promise<void>
+  task: (stagedFileNames: readonly string[]) => void | Promise<void>
 }
 
 export type Configuration =
@@ -19,6 +19,11 @@ export type Options = {
    * @default false
    */
   allowEmpty?: boolean
+  /**
+   * Enable or disable ANSI color codes in output. By default value is auto-detected
+   * and controlled by `FORCE_COLOR` or `NO_COLOR` env variables.
+   */
+  color?: boolean
   /**
    * The number of tasks to run concurrently, or `false` to run tasks serially
    * @default true
@@ -61,7 +66,7 @@ export type Options = {
    * Fail with exit code 1 when tasks modify tracked files
    * @default false
    */
-  failOnChanges?: true
+  failOnChanges?: boolean
   /**
    * Maximum argument string length, by default automatically detected
    */
@@ -104,12 +109,13 @@ export type Options = {
   verbose?: boolean
 }
 
-type LogFunction = (...params: any) => void
+type LogFunction = typeof console.log
 
 type Logger = {
   log: LogFunction
   warn: LogFunction
   error: LogFunction
+  debug: LogFunction
 }
 
 /**

package/lib/index.js

@@ -6,7 +6,7 @@ import {
   NO_CONFIGURATION,
   PREVENTED_EMPTY_COMMIT,
   PREVENTED_TASK_MODIFICATIONS,
-  RESTORE_STASH_EXAMPLE,
+  restoreStashExample,
   UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
 } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
@@ -15,7 +15,7 @@ import { cleanupSkipped } from './state.js'
 import {
   ApplyEmptyCommitError,
   ConfigNotFoundError,
-  ExitCodeError,
+  FailOnChangesError,
   GetBackupStashError,
   GitError,
   RestoreUnstagedChangesError,
@@ -51,7 +51,7 @@ const getMaxArgLength = () => {
  *
  * @param {object} options
  * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
- * @param {Object} [options.color] - Enable ANSI colors in output
+ * @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.config] - Object with configuration for programmatic API
  * @param {string} [options.configPath] - Path to configuration file
@@ -86,8 +86,8 @@ const lintStaged = async (
     diff,
     diffFilter,
     failOnChanges = false,
-    hidePartiallyStaged = true,
     hideUnstaged = false,
+    hidePartiallyStaged = !hideUnstaged,
     maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
@@ -155,8 +155,9 @@ const lintStaged = async (
         logger.error(NO_CONFIGURATION)
       } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
-      } else if (ctx.errors.has(ExitCodeError)) {
-        logger.warn(PREVENTED_TASK_MODIFICATIONS)
+      } else if (ctx.errors.has(FailOnChangesError)) {
+        logger.warn(PREVENTED_TASK_MODIFICATIONS + '\n')
+        logger.warn(restoreStashExample(ctx.backupHash))
       } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
         logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
         logger.warn(ctx.unstagedPatch)
@@ -167,7 +168,7 @@ const lintStaged = async (
         logger.error(GIT_ERROR)
         if (ctx.shouldBackup) {
           // No sense to show this if the backup stash itself is missing.
-          logger.error(RESTORE_STASH_EXAMPLE + '\n')
+          logger.error(restoreStashExample(ctx.backupHash) + '\n')
         }
       }
 

package/lib/loadConfig.js

@@ -2,25 +2,28 @@
 
 import fs from 'node:fs/promises'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 import YAML from 'yaml'
 
 import { CONFIG_NAME, PACKAGE_JSON_FILE, PACKAGE_YAML_FILES } from './configFiles.js'
 import { createDebug } from './debug.js'
-import { dynamicImport } from './dynamicImport.js'
 import { failedToLoadConfig } from './messages.js'
 import { resolveConfig } from './resolveConfig.js'
 
 const debugLog = createDebug('lint-staged:loadConfig')
 
-const jsonParse = (filePath, content) => {
-  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filePath))
+const readFile = async (filename) => fs.readFile(path.resolve(filename), 'utf-8')
+
+const jsonParse = async (filename) => {
+  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filename))
   try {
+    const content = await readFile(filename)
     const json = JSON.parse(content)
     return isPackageFile ? json[CONFIG_NAME] : json
   } catch (error) {
-    if (path.basename(filePath) === PACKAGE_JSON_FILE) {
-      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+    if (path.basename(filename) === PACKAGE_JSON_FILE) {
+      debugLog('Ignoring invalid JSON file %s', filename)
       return undefined
     }
 
@@ -28,14 +31,15 @@ const jsonParse = (filePath, content) => {
   }
 }
 
-const yamlParse = (filePath, content) => {
-  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filePath))
+const yamlParse = async (filename) => {
+  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filename))
   try {
+    const content = await readFile(filename)
     const yaml = YAML.parse(content)
     return isPackageFile ? yaml[CONFIG_NAME] : yaml
   } catch (error) {
     if (isPackageFile) {
-      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+      debugLog('Ignoring invalid YAML file %s', filename)
       return undefined
     }
 
@@ -43,6 +47,8 @@ const yamlParse = (filePath, content) => {
   }
 }
 
+export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)
+
 const NO_EXT = 'noExt'
 
 /**
@@ -64,43 +70,30 @@ const loaders = {
   '.yml': yamlParse,
 }
 
-const readFile = async (filepath) => {
-  const absolutePath = path.resolve(filepath)
-  return fs.readFile(absolutePath, 'utf-8')
-}
-
-const loadConfigByExt = async (filepath) => {
-  filepath = path.resolve(filepath)
+const loadConfigByExt = async (filename) => {
+  const filepath = path.resolve(filename)
   const ext = path.extname(filepath) || NO_EXT
   const loader = loaders[ext]
+  const config = await loader(filepath)
 
-  /**
-   * No need to read file contents when loader only takes in the filepath argument
-   * and reads itself; this is for `lilconfig` compatibility
-   */
-  const content = loader.length > 1 ? await readFile(filepath) : undefined
-
-  return {
-    config: await loader(filepath, content),
-    filepath,
-  }
+  return { config, filepath }
 }
 
-/**
- * @param {object} options
- * @param {string} [options.configPath] - Explicit path to a config file
- */
-export const loadConfig = async ({ configPath }, logger) => {
+/** @param {string} configPath */
+export const loadConfig = async (configPath, logger) => {
   try {
     debugLog('Loading configuration from `%s`...', configPath)
-    const result = configPath ? await loadConfigByExt(resolveConfig(configPath)) : undefined
-    if (!result) return {}
+    const result = await loadConfigByExt(resolveConfig(configPath))
 
     // config is a promise when using the `dynamicImport` loader
     const config = (await result.config) ?? null
     const filepath = result.filepath
 
-    debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+    if (config) {
+      debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+    } else {
+      debugLog('Found no config in %s', filepath)
+    }
 
     return { config, filepath }
   } catch (error) {

package/lib/messages.js

@@ -66,11 +66,13 @@ export const PREVENTED_EMPTY_COMMIT = `
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
-export const RESTORE_STASH_EXAMPLE = `Any lost modifications can be restored from a git stash:
+export const restoreStashExample = (
+  hash = 'h0a0s0h0'
+) => `Any lost modifications can be restored from a git stash:
 
-  > git stash list
-  stash@{0}: automatic lint-staged backup
-  > git stash apply --index stash@{0}`
+  > git stash list --format="%h %s"
+  ${hash} On main: lint-staged automatic backup
+  > git apply --index ${hash}`
 
 export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
 

package/lib/runAll.js

@@ -36,7 +36,8 @@ import {
   restoreOriginalStateEnabled,
   restoreOriginalStateSkipped,
   restoreUnstagedChangesSkipped,
-  shouldHideUnstagedFiles,
+  shouldHidePartiallyStagedFiles,
+  shouldRestoreUnstagedChanges,
 } from './state.js'
 import { ConfigNotFoundError, GetStagedFilesError, GitError, GitRepoError } from './symbols.js'
 
@@ -54,7 +55,7 @@ const createError = (ctx, cause) =>
  *
  * @param {object} options
  * @param {boolean} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
- * @param {Object} [options.color] - Enable ANSI colors in output
+ * @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
@@ -88,8 +89,8 @@ export const runAll = async (
     diff,
     diffFilter,
     failOnChanges = false,
-    hidePartiallyStaged = true,
     hideUnstaged = false,
+    hidePartiallyStaged = !hideUnstaged,
     maxArgLength,
     quiet = false,
     relative = false,
@@ -135,7 +136,7 @@ export const runAll = async (
     logger.warn(skippingBackup(hasInitialCommit, diff))
   }
 
-  if (!ctx.shouldHidePartiallyStaged && !quiet) {
+  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !quiet) {
     logger.warn(SKIPPING_HIDE_PARTIALLY_CHANGED)
   }
 
@@ -330,8 +331,8 @@ export const runAll = async (
       },
       {
         title: 'Hiding unstaged changes to partially staged files...',
-        task: (ctx) => git.hideUnstagedChanges(ctx),
-        enabled: shouldHideUnstagedFiles,
+        task: (ctx) => git.hidePartiallyStagedChanges(ctx),
+        enabled: shouldHidePartiallyStagedFiles,
       },
       {
         title: `Running tasks for ${diff ? 'changed' : 'staged'} files...`,
@@ -344,9 +345,9 @@ export const runAll = async (
         skip: applyModificationsSkipped,
       },
       {
-        title: 'Restoring unstaged changes to partially staged files...',
+        title: 'Restoring unstaged changes...',
         task: (ctx) => git.restoreUnstagedChanges(ctx),
-        enabled: shouldHideUnstagedFiles,
+        enabled: shouldRestoreUnstagedChanges,
         skip: restoreUnstagedChangesSkipped,
       },
       {

package/lib/searchConfigs.js

@@ -19,6 +19,8 @@ const CONFIG_PATHSPEC = CONFIG_FILE_NAMES.map((f) => `:(glob)**/${f}`)
 
 const numberOfLevels = (file) => file.split('/').length
 
+const sortAlphabetically = (a, b) => a.localeCompare(b)
+
 const sortDeepestParth = (a, b) => (numberOfLevels(a) > numberOfLevels(b) ? -1 : 1)
 
 /**
@@ -43,22 +45,20 @@ const listConfigFilesFromGit = async ({ cwd, topLevelDir }) =>
   )
     .then(parseGitZOutput)
     .then((lines) => {
-      const possibleConfigFiles = lines
-        .flatMap((line) => {
-          /**
-           * Leave out lines starting with "S " to ignore not-checked-out files in a sparse repo.
-           * The "S" status means a tracked file that is "skip-worktree"
-           * @see https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--t
-           */
-          if (line.startsWith('S ')) {
-            return []
-          }
+      const possibleConfigFiles = lines.flatMap((line) => {
+        /**
+         * Leave out lines starting with "S " to ignore not-checked-out files in a sparse repo.
+         * The "S" status means a tracked file that is "skip-worktree"
+         * @see https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--t
+         */
+        if (line.startsWith('S ')) {
+          return []
+        }
 
-          const relativePath = line.replace(/^[HSMRCK?U] /, '')
-          const absolutePath = normalizePath(path.join(topLevelDir, relativePath))
-          return [absolutePath]
-        })
-        .sort(sortDeepestParth)
+        const relativePath = line.replace(/^[HSMRCK?U] /, '')
+        const absolutePath = normalizePath(path.join(topLevelDir, relativePath))
+        return [absolutePath]
+      })
 
       debugLog('Found possible config files from git:', possibleConfigFiles)
 
@@ -91,7 +91,7 @@ export const listConfigFilesFromFs = async ({ cwd }) => {
 
   if (possibleConfigFiles.length > 0) {
     debugLog('Found possible config files from filesystem:', possibleConfigFiles)
-    return possibleConfigFiles.sort((a, b) => a.localeCompare(b))
+    return possibleConfigFiles
   }
 
   const parentDir = path.dirname(cwd)
@@ -131,27 +131,35 @@ export const searchConfigs = async (
   if (configPath) {
     debugLog('Using single configuration path...')
 
-    const { config, filepath } = await loadConfig({ configPath }, logger)
+    const { config, filepath } = await loadConfig(configPath, logger)
 
     if (!config) return {}
     return { [configPath]: validateConfig(config, filepath, logger) }
   }
 
-  let possibleConfigFiles = await listConfigFilesFromGit({ cwd, topLevelDir })
-  if (possibleConfigFiles.length === 0) {
-    possibleConfigFiles = await listConfigFilesFromFs({ cwd })
+  const possibleConfigFiles = new Set()
+
+  const addToSet = (files) => {
+    files.forEach((f) => {
+      possibleConfigFiles.add(f)
+    })
   }
 
+  await Promise.all([
+    listConfigFilesFromGit({ cwd, topLevelDir }).then(addToSet),
+    listConfigFilesFromFs({ cwd }).then(addToSet),
+  ])
+
   /** Create object with key as config file, and value as null */
-  const configs = possibleConfigFiles.reduce(
-    (acc, configPath) => Object.assign(acc, { [configPath]: null }),
-    {}
-  )
+  const configs = Array.from(possibleConfigFiles)
+    .sort(sortAlphabetically)
+    .sort(sortDeepestParth)
+    .reduce((acc, configPath) => Object.assign(acc, { [configPath]: null }), {})
 
   /** Load and validate all configs to the above object */
   await Promise.all(
     Object.keys(configs).map((configPath) =>
-      loadConfig({ configPath }, logger).then(({ config, filepath }) => {
+      loadConfig(configPath, logger).then(({ config, filepath }) => {
         if (config) {
           if (configPath !== filepath) {
             debugLog('Config file "%s" resolved to "%s"', configPath, filepath)

package/lib/state.js

@@ -2,7 +2,7 @@ import EventEmitter from 'events'
 
 import { GIT_ERROR, TASK_ERROR } from './messages.js'
 import {
-  ExitCodeError,
+  FailOnChangesError,
   GitError,
   RestoreOriginalStateError,
   RestoreUnstagedChangesError,
@@ -10,14 +10,15 @@ import {
 } from './symbols.js'
 
 export const getInitialState = ({
-  hidePartiallyStaged = true,
   hideUnstaged = false,
+  hidePartiallyStaged = !hideUnstaged,
   quiet = false,
   revert = true,
 } = {}) => ({
   backupHash: null,
   errors: new Set([]),
   events: new EventEmitter(),
+  shouldFailOnChanges: null,
   hasFilesToHide: null,
   output: [],
   quiet,
@@ -28,16 +29,21 @@ export const getInitialState = ({
   unstagedPatch: null,
 })
 
-export const shouldHideUnstagedFiles = (ctx) =>
+export const shouldHidePartiallyStagedFiles = (ctx) =>
+  ctx.shouldHidePartiallyStaged && ctx.hasFilesToHide
+
+export const shouldRestoreUnstagedChanges = (ctx) =>
   (ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) && ctx.hasFilesToHide
 
 export const applyModificationsSkipped = (ctx) => {
   // Always apply back unstaged modifications when skipping revert or backup
   if (!ctx.shouldRevert || !ctx.shouldBackup) return false
+
   // Should be skipped in case of git errors
   if (ctx.errors.has(GitError)) {
     return GIT_ERROR
   }
+
   // Should be skipped when tasks fail
   if (ctx.errors.has(TaskError)) {
     return TASK_ERROR
@@ -50,6 +56,13 @@ export const restoreUnstagedChangesSkipped = (ctx) => {
     return GIT_ERROR
   }
 
+  // When complete reverting to original state is skipped,
+  // we can still restore unstaged changes to make it easier
+  // to do manually.
+  if (!ctx.shouldRevert) {
+    false
+  }
+
   // Should be skipped when tasks fail
   if (ctx.errors.has(TaskError)) {
     return TASK_ERROR
@@ -59,17 +72,13 @@ export const restoreUnstagedChangesSkipped = (ctx) => {
 export const restoreOriginalStateEnabled = (ctx) =>
   !!ctx.shouldRevert &&
   !!ctx.shouldBackup &&
-  (ctx.errors.has(ExitCodeError) ||
+  (ctx.errors.has(FailOnChangesError) ||
     ctx.errors.has(TaskError) ||
     ctx.errors.has(RestoreUnstagedChangesError))
 
 export const restoreOriginalStateSkipped = (ctx) => {
   // Should be skipped in case of unknown git errors
-  if (
-    ctx.errors.has(GitError) &&
-    !ctx.errors.has(RestoreUnstagedChangesError) &&
-    !ctx.errors.has(ExitCodeError)
-  ) {
+  if (ctx.errors.has(GitError) && !ctx.errors.has(RestoreUnstagedChangesError)) {
     return GIT_ERROR
   }
 }
@@ -77,6 +86,11 @@ export const restoreOriginalStateSkipped = (ctx) => {
 export const cleanupEnabled = (ctx) => ctx.shouldBackup
 
 export const cleanupSkipped = (ctx) => {
+  // "--fail-on-changes" was used, so we shouldn't drop the backup stash
+  if (ctx.errors.has(FailOnChangesError) && !ctx.shouldRevert) {
+    return true
+  }
+
   // Should be skipped in case of unknown git errors
   if (restoreOriginalStateSkipped(ctx)) {
     return GIT_ERROR

package/lib/symbols.js

@@ -26,4 +26,4 @@ export const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
 
 export const TaskError = Symbol('TaskError')
 
-export const ExitCodeError = Symbol('ExitCodeError')
+export const FailOnChangesError = Symbol('FailOnChangesError')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "16.2.0",
+  "version": "16.2.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {
@@ -48,25 +48,25 @@
     "tag": "npx changeset tag"
   },
   "dependencies": {
-    "commander": "14.0.1",
-    "listr2": "9.0.4",
-    "micromatch": "4.0.8",
-    "nano-spawn": "1.0.3",
-    "pidtree": "0.6.0",
-    "string-argv": "0.3.2",
-    "yaml": "2.8.1"
+    "commander": "^14.0.1",
+    "listr2": "^9.0.4",
+    "micromatch": "^4.0.8",
+    "nano-spawn": "^1.0.3",
+    "pidtree": "^0.6.0",
+    "string-argv": "^0.3.2",
+    "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@changesets/changelog-github": "0.5.1",
     "@changesets/cli": "2.29.7",
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
-    "@eslint/js": "9.35.0",
+    "@eslint/js": "9.36.0",
     "@vitest/coverage-v8": "3.2.4",
     "@vitest/eslint-plugin": "1.3.12",
     "consolemock": "1.1.0",
     "cross-env": "10.0.0",
-    "eslint": "9.35.0",
+    "eslint": "9.36.0",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-n": "17.23.1",
     "eslint-plugin-prettier": "5.5.4",

package/lib/dynamicImport.js

@@ -1,3 +0,0 @@
-import { pathToFileURL } from 'node:url'
-
-export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)