lint-staged 16.4.0 → 17.0.0

package/lib/colors.js

@@ -1,106 +1,11 @@
-import nodeTty from 'node:tty'
+/* eslint-disable n/no-unsupported-features/node-builtins */
 
-/**
- * @example NO_COLOR
- * @example NO_COLOR=1
- * @example NO_COLOR=true
- */
-const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
+import util from 'node:util'
 
-/**
- * @example FORCE_COLOR=0
- * @example FORCE_COLOR=false
- */
-const FALSY_ENV_VAR_VALUES = ['0', 'false']
+export const SUPPORTS_COLOR = !!process.stdout.hasColors?.()
 
-/**
- * @returns `true` if ANSI colors are supported
- *
- * @param {NodeJS.Process} [p]
- * @param {boolean} [isTty]
- */
-export const supportsAnsiColors = (p = process, isTty = nodeTty.isatty(1)) => {
-  const noColor = p?.env?.NO_COLOR?.toLowerCase()
-  if (TRUTHRY_ENV_VAR_VALUES.includes(noColor)) {
-    return false
-  }
-
-  const forceColor = p?.env?.FORCE_COLOR?.toLowerCase()
-  if (TRUTHRY_ENV_VAR_VALUES.includes(forceColor)) {
-    return true
-  } else if (FALSY_ENV_VAR_VALUES.includes(forceColor)) {
-    return false
-  }
-
-  const forceTty = p?.env?.FORCE_TTY
-  if (TRUTHRY_ENV_VAR_VALUES.includes(forceTty)) {
-    return true
-  } else if (FALSY_ENV_VAR_VALUES.includes(forceTty)) {
-    return false
-  }
-
-  if (isTty) {
-    return true
-  }
-
-  /**
-   * Assume CI supports color
-   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
-   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L91}
-   */
-  if (TRUTHRY_ENV_VAR_VALUES.includes(p?.env?.CI)) {
-    return true
-  }
-
-  if (p?.env?.TERM && p.env.TERM === 'dumb') {
-    return false
-  }
-
-  /**
-   * Assume Windows supports color
-   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
-   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L89}
-   */
-  if (p?.platform === 'win32') {
-    return true
-  }
-
-  return false
-}
-
-/**
- * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
- * @example util.styleText('red', 'test') !== 'text'
- */
-export const SUPPORTS_COLOR = supportsAnsiColors()
-
-const ANSI_RESET = '\u001B[0m'
-
-/**
- * @callback WrapAnsi
- * @param {string} text
- * @returns {string}
- */
-/**
- * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
- * @example (format) => (text) => util.styleText(format, text)
- *
- * @param {string} code
- * @param {boolean} [supported]
- * @returns {WrapAnsi}
- *
- */
-export const wrapAnsiColor = (code, supported = SUPPORTS_COLOR) => {
-  if (supported) {
-    return (text) => code + text + ANSI_RESET
-  }
-
-  return (text) => text
-}
-
-export const red = wrapAnsiColor('\u001B[0;31m')
-export const green = wrapAnsiColor('\u001B[0;32m')
-export const yellow = wrapAnsiColor('\u001B[0;33m')
-export const blue = wrapAnsiColor('\u001B[0;34m')
-export const blackBright = wrapAnsiColor('\u001B[0;90m')
-export const bold = wrapAnsiColor('\u001b[1m')
+export const red = (text) => (SUPPORTS_COLOR ? util.styleText('red', text) : text)
+export const yellow = (text) => (SUPPORTS_COLOR ? util.styleText('yellow', text) : text)
+export const blue = (text) => (SUPPORTS_COLOR ? util.styleText('blue', text) : text)
+export const dim = (text) => (SUPPORTS_COLOR ? util.styleText('dim', text) : text)
+export const bold = (text) => (SUPPORTS_COLOR ? util.styleText('bold', text) : text)

package/lib/debug.js

@@ -1,15 +1,13 @@
 import { formatWithOptions } from 'node:util'
 
-import { blackBright, SUPPORTS_COLOR } from './colors.js'
+import { dim, SUPPORTS_COLOR } from './colors.js'
 
 const format = (...args) => formatWithOptions({ colors: SUPPORTS_COLOR }, ...args)
 
 let activeLogger
 
 export const enableDebug = (logger = console) => {
-  if (!activeLogger) {
-    activeLogger = logger
-  }
+  activeLogger = logger
 }
 
 /** @param {string} name */
@@ -22,6 +20,6 @@ export const createDebug = (name) => {
     const now = process.hrtime.bigint()
     const ms = (now - previous) / 1_000_000n
     previous = now
-    activeLogger.debug(blackBright(name + ': ') + format(...args) + blackBright(` +${ms}ms`))
+    activeLogger.debug(dim(name + ': ') + format(...args) + dim(` +${ms}ms`))
   }
 }

package/lib/getRenderer.js

@@ -45,7 +45,7 @@ const getMainRendererOptions = ({ color, debug, quiet }, logger, env) => {
   }
 }
 
-const getFallbackRenderer = ({ renderer }, { color = false }) => {
+const getFallbackRenderer = ({ renderer }, { color }) => {
   if (renderer === 'silent' || renderer === 'test' || !color) {
     return renderer
   }

package/lib/getSpawnedTask.js

@@ -1,7 +1,7 @@
 import { parseArgsStringToArgv } from 'string-argv'
 import { exec } from 'tinyexec'
 
-import { blackBright, red } from './colors.js'
+import { dim, red } from './colors.js'
 import { createDebug } from './debug.js'
 import { error, info } from './figures.js'
 import { Signal } from './getAbortController.js'
@@ -51,7 +51,7 @@ const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
  */
 export const createTaskError = (command, result, ctx, signal = 'FAILED') => {
   ctx.errors.add(TaskError)
-  return new Error(`${red(command)} ${blackBright(`[${signal}]`)}`, { cause: result })
+  return new Error(`${red(command)} ${dim(`[${signal}]`)}`, { cause: result })
 }
 
 /**

package/lib/gitWorkflow.js

@@ -1,11 +1,11 @@
 import crypto from 'node:crypto'
-import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
+import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import {
   ApplyEmptyCommitError,
@@ -79,26 +79,14 @@ const cleanGitStashOutput = (lines) => lines.map((line) => line.replace(/^"(.*)"
 export class GitWorkflow {
   /**
    * @param {Object} opts
-   * @param {import('./getStagedFiles.js').StagedFile[][]} opts.matchedFileChunks
    */
-  constructor({
-    allowEmpty,
-    diff,
-    diffFilter,
-    failOnChanges,
-    gitConfigDir,
-    matchedFileChunks,
-    topLevelDir,
-  }) {
+  constructor({ allowEmpty, diff, diffFilter, failOnChanges, gitConfigDir, topLevelDir }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: topLevelDir })
     this.allowEmpty = allowEmpty
-    this.deletedFiles = []
     this.diff = diff
     this.diffFilter = diffFilter
     this.gitConfigDir = gitConfigDir
     this.failOnChanges = !!failOnChanges
-    /** @type {import('./getStagedFiles.js').StagedFile[][]} */
-    this.matchedFileChunks = matchedFileChunks
     this.topLevelDir = topLevelDir
 
     /**
@@ -137,20 +125,6 @@ export class GitWorkflow {
     return String(index)
   }
 
-  /**
-   * Get a list of unstaged deleted files
-   */
-  async getDeletedFiles() {
-    debugLog('Getting deleted files...')
-    const lsFiles = await this.execGit(['ls-files', '--deleted'])
-    const deletedFiles = lsFiles
-      .split('\n')
-      .filter(Boolean)
-      .map((file) => path.resolve(this.topLevelDir, file))
-    debugLog('Found deleted files:', deletedFiles)
-    return deletedFiles
-  }
-
   /**
    * Save meta information about ongoing git merge
    */
@@ -234,14 +208,9 @@ export class GitWorkflow {
       if (ctx.shouldBackup) {
         // When backup is enabled, the revert will clear ongoing merge status.
         await this.backupMergeStatus()
-
-        // Get a list of unstaged deleted files, because certain bugs might cause them to reappear:
-        // - 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()
       }
 
-      if (ctx.shouldHideUnstaged) {
+      if (ctx.shouldHideUnstaged || ctx.shouldHideAll) {
         this.unstagedFiles = await this.getUnstagedFiles({ onlyPartial: false })
         ctx.hasFilesToHide = !!this.unstagedFiles
       } else if (ctx.shouldHidePartiallyStaged) {
@@ -257,9 +226,11 @@ export class GitWorkflow {
       }
 
       if (ctx.shouldBackup) {
-        if (ctx.shouldHideUnstaged) {
+        if (ctx.shouldHideUnstaged || ctx.shouldHideAll) {
+          const args = ['stash', 'push', '--keep-index', '--message', STASH]
+          if (ctx.shouldHideAll) args.push('--include-untracked')
           /** Save stash of all changes, clearing the working tree but keeping staged files as-is */
-          await this.execGit(['stash', 'push', '--keep-index', '--message', STASH])
+          await this.execGit(args)
           /** Print stash list with short hash and subject */
           const stashes = await this.execGit(['stash', 'list', '--format="%h %s"', '-z'])
             .then(parseGitZOutput)
@@ -285,7 +256,7 @@ export class GitWorkflow {
   async hidePartiallyStagedChanges(ctx) {
     try {
       const files = processRenames(this.unstagedFiles, false)
-      await this.execGit(['checkout', '--force', '--', ...files])
+      await this.execGit(['restore', '--worktree', '--', ...files])
     } catch (error) {
       /**
        * `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
@@ -308,11 +279,8 @@ export class GitWorkflow {
     return task.newListr(listrTasks, { concurrent })
   }
 
-  /**
-   * Applies back task modifications, and unstaged changes hidden in the stash.
-   * In case of a merge-conflict retry with 3-way merge.
-   */
-  async applyModifications(ctx) {
+  /** Update Git index again for the originally staged files to stage task modifications. */
+  async updateIndex(ctx) {
     if (ctx.shouldFailOnChanges) {
       debugLog(
         'Calculating SHA-256 hash of changes after tasks because "--fail-on-changes" was used...'
@@ -326,32 +294,18 @@ export class GitWorkflow {
       }
     }
 
-    debugLog('Adding task modifications to index...')
-
-    // `matchedFileChunks` includes staged files that lint-staged originally detected and matched against a task.
-    // Add only these files so any 3rd-party edits to other files won't be included in the commit.
-    // These additions per chunk are run "serially" to prevent race conditions.
-    // Git add creates a lockfile in the repo causing concurrent operations to fail.
-    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
-          }
-        })
-      )
+    // Unset GIT_INDEX_FILE so that the default index is always updated after running tasks
+    // Otherwise committing a pathspec (which uses a temporary non-default index) will leave
+    // changes in the worktree and default index
+    debugLog('Unset GIT_INDEX_FILE (was `%s`)', process.env.GIT_INDEX_FILE)
+    delete process.env.GIT_INDEX_FILE
 
-      const addableFiles = accessCheckedFiles.flatMap((r) =>
-        r.status === 'fulfilled' ? [r.value] : []
-      )
+    debugLog('Updating Git index again after task modifications...')
 
-      await this.execGit(['add', '--', ...addableFiles])
-    }
+    // Update index for the files that were originally staged, ignore others
+    await this.execGit(['update-index', '--again'])
 
-    debugLog('Done adding task modifications to index!')
+    debugLog('Done updating Git index again after task modifications!')
 
     const stagedFilesAfterAdd = await this.execGit([
       ...getDiffCommand(this.diff, this.diffFilter),
@@ -395,6 +349,42 @@ export class GitWorkflow {
     }
   }
 
+  async restoreUntrackedFiles(ctx) {
+    try {
+      debugLog('Restoring untracked files...')
+      const backupStash = await this.getBackupStash(ctx)
+      const untrackedFiles = await this.execGit([
+        'stash',
+        'show',
+        '--only-untracked',
+        '--name-only',
+        '-z',
+        backupStash,
+      ]).then(parseGitZOutput)
+
+      if (untrackedFiles.length) {
+        debugLog('Found untracked files: %s', untrackedFiles)
+        await this.execGit([
+          'restore',
+          '--source',
+          `${ctx.backupHash}^3`,
+          '--',
+          ...untrackedFiles.map(normalizePath),
+        ])
+      } else {
+        debugLog('No untracked files to restore!')
+      }
+    } catch (restoreUntrackedFilesError) {
+      debugLog('Error while restoring untracked files:')
+      debugLog(restoreUntrackedFilesError)
+      handleError(
+        new Error('Untracked files could not be restored!'),
+        ctx,
+        RestoreUnstagedChangesError
+      )
+    }
+  }
+
   /**
    * Restore original HEAD state in case of errors
    */
@@ -407,9 +397,6 @@ export class GitWorkflow {
       // Restore meta information about ongoing git merge
       await this.restoreMergeStatus(ctx)
 
-      // If stashing resurrected deleted files, clean them out
-      await Promise.all(this.deletedFiles.map((file) => unlink(file)))
-
       // Clean out patch
       await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
 

package/lib/index.d.ts

@@ -81,6 +81,11 @@ export type Options = {
    * @default false
    */
   hideUnstaged?: boolean
+  /**
+   * Whether to hide all unstaged changes and untracked files before running tasks
+   * @default false
+   */
+  hideAll?: boolean
   /**
    * Disable lint-staged’s own console output
    * @default false

package/lib/index.js

@@ -1,8 +1,10 @@
+import { assertGitVersion, MIN_GIT_VERSION } from './assertGitVersion.js'
 import { SUPPORTS_COLOR } from './colors.js'
 import { createDebug, enableDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import {
   GIT_ERROR,
+  minGitVersionRequired,
   NO_CONFIGURATION,
   PREVENTED_EMPTY_COMMIT,
   PREVENTED_TASK_MODIFICATIONS,
@@ -86,8 +88,9 @@ const lintStaged = async (
     diff,
     diffFilter,
     failOnChanges = false,
+    hideAll = false,
     hideUnstaged = false,
-    hidePartiallyStaged = !hideUnstaged,
+    hidePartiallyStaged = !(hideAll || hideUnstaged),
     maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
@@ -114,6 +117,10 @@ const lintStaged = async (
   const gitVersion = await execGit(['version', '--build-options'], { cwd })
   debugLog('%s', gitVersion)
 
+  if (!assertGitVersion(gitVersion)) {
+    throw new Error(minGitVersionRequired(MIN_GIT_VERSION, gitVersion), { cause: gitVersion })
+  }
+
   const options = {
     allowEmpty,
     color,
@@ -126,6 +133,7 @@ const lintStaged = async (
     diff,
     diffFilter,
     failOnChanges,
+    hideAll,
     hidePartiallyStaged,
     hideUnstaged,
     maxArgLength,

package/lib/messages.js

@@ -67,12 +67,13 @@ export const PREVENTED_EMPTY_COMMIT = `
 `
 
 export const restoreStashExample = (
-  hash = 'h0a0s0h0'
+  hash = '<git-hash>'
 ) => `Any lost modifications can be restored from a git stash:
 
   > git stash list --format="%h %s"
   ${hash} On main: lint-staged automatic backup
-  > git apply --index ${hash}`
+  > git apply --index ${hash}
+`
 
 export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
 
@@ -89,3 +90,8 @@ ${error}
 See https://github.com/okonet/lint-staged#configuration.`
 
 export const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `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)}.
+
+Please update Git: https://git-scm.com/downloads`)

package/lib/runAll.js

@@ -5,7 +5,7 @@ import path from 'node:path'
 import { Listr } from 'listr2'
 
 import { chunkFiles } from './chunkFiles.js'
-import { blackBright } from './colors.js'
+import { dim } from './colors.js'
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
@@ -30,7 +30,6 @@ import { normalizePath } from './normalizePath.js'
 import { resolveGitRepo } from './resolveGitRepo.js'
 import { searchConfigs } from './searchConfigs.js'
 import {
-  applyModificationsSkipped,
   cleanupEnabled,
   cleanupSkipped,
   getInitialState,
@@ -39,6 +38,8 @@ import {
   restoreUnstagedChangesSkipped,
   shouldHidePartiallyStagedFiles,
   shouldRestoreUnstagedChanges,
+  shouldRestoreUntrackedFiles,
+  updateIndexSkipped,
 } from './state.js'
 import { ConfigNotFoundError, GetStagedFilesError, GitError, GitRepoError } from './symbols.js'
 
@@ -90,8 +91,9 @@ export const runAll = async (
     diff,
     diffFilter,
     failOnChanges = false,
+    hideAll = false,
     hideUnstaged = false,
-    hidePartiallyStaged = !hideUnstaged,
+    hidePartiallyStaged = !(hideAll || hideUnstaged),
     maxArgLength,
     quiet = false,
     relative = false,
@@ -112,8 +114,9 @@ export const runAll = async (
 
   const ctx = getInitialState({
     failOnChanges,
-    hidePartiallyStaged,
+    hideAll,
     hideUnstaged,
+    hidePartiallyStaged,
     quiet,
     revert,
   })
@@ -138,7 +141,7 @@ export const runAll = async (
     logger.warn(skippingBackup(hasInitialCommit, diff))
   }
 
-  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !quiet) {
+  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !ctx.shouldHideAll && !quiet) {
     logger.warn(SKIPPING_HIDE_PARTIALLY_CHANGED)
   }
 
@@ -204,7 +207,7 @@ export const runAll = async (
     // 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 = hasMultipleConfigs && !hasExplicitCwd ? path.dirname(configPath) : cwd
+    const groupCwd = hasExplicitCwd || !hasMultipleConfigs ? cwd : path.dirname(configPath)
 
     const chunkCount = stagedFileChunks.length
     if (chunkCount > 1) {
@@ -248,7 +251,7 @@ export const runAll = async (
             const fileCount = task.fileList.length
 
             return {
-              title: `${task.pattern}${blackBright(
+              title: `${task.pattern}${dim(
                 ` — ${fileCount} ${fileCount === 1 ? 'file' : 'files'}`
               )}`,
               task: async (ctx, task) =>
@@ -260,7 +263,7 @@ export const runAll = async (
               skip: () => {
                 // Skip task when no files matched
                 if (fileCount === 0) {
-                  return `${task.pattern}${blackBright(' — no files')}`
+                  return `${task.pattern}${dim(' — no files')}`
                 }
                 return false
               },
@@ -271,8 +274,8 @@ export const runAll = async (
 
       listrTasks.push({
         title:
-          `${configName}${blackBright(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
-          (chunkCount > 1 ? blackBright(` (chunk ${index + 1}/${chunkCount})...`) : ''),
+          `${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 }),
         skip: () => {
@@ -280,7 +283,7 @@ export const runAll = async (
           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())) {
-            return `${configName}${blackBright(' — no tasks to run')}`
+            return `${configName}${dim(' — no tasks to run')}`
           }
           return false
         },
@@ -299,23 +302,12 @@ 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,
     diffFilter,
     failOnChanges,
     gitConfigDir,
-    matchedFileChunks,
     topLevelDir,
   })
 
@@ -336,9 +328,9 @@ export const runAll = async (
         skip: () => listrTasks.every((task) => task.skip()),
       },
       {
-        title: 'Applying modifications from tasks...',
-        task: (ctx) => git.applyModifications(ctx),
-        skip: applyModificationsSkipped,
+        title: 'Updating Git index again...',
+        task: (ctx) => git.updateIndex(ctx),
+        skip: updateIndexSkipped,
       },
       {
         title: 'Restoring unstaged changes...',
@@ -346,6 +338,12 @@ export const runAll = async (
         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),

package/lib/state.js

@@ -9,32 +9,48 @@ import {
 
 export const getInitialState = ({
   failOnChanges = false,
+  hideAll = false,
   hideUnstaged = false,
-  hidePartiallyStaged = !hideUnstaged,
+  hidePartiallyStaged = !(hideAll || hideUnstaged),
   quiet = false,
   revert = true,
-} = {}) => ({
-  backupHash: null,
-  errors: new Set([]),
-  shouldFailOnChanges: failOnChanges,
-  hasFilesToHide: null,
-  output: [],
-  quiet,
-  shouldBackup: null,
-  shouldHidePartiallyStaged: hidePartiallyStaged,
-  shouldHideUnstaged: hideUnstaged,
-  shouldRevert: revert,
-  unstagedDiffSha256: null,
-  unstagedPatch: null,
-})
+} = {}) => {
+  const initialState = {
+    backupHash: null,
+    errors: new Set([]),
+    shouldFailOnChanges: failOnChanges,
+    hasFilesToHide: null,
+    output: [],
+    quiet,
+    shouldBackup: null,
+    shouldHideAll: hideAll,
+    shouldHideUnstaged: hideUnstaged,
+    shouldHidePartiallyStaged: hidePartiallyStaged,
+    shouldRevert: revert,
+    unstagedDiffSha256: null,
+    unstagedPatch: null,
+  }
+
+  if (initialState.shouldHideAll) {
+    initialState.shouldHideUnstaged = false // becomes redundant
+    initialState.shouldHidePartiallyStaged = false // becomes redundant
+  } else if (initialState.shouldHideUnstaged) {
+    initialState.shouldHidePartiallyStaged = false // becomes redundant
+  }
+
+  return initialState
+}
 
 export const shouldHidePartiallyStagedFiles = (ctx) =>
   ctx.shouldHidePartiallyStaged && ctx.hasFilesToHide
 
 export const shouldRestoreUnstagedChanges = (ctx) =>
-  (ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) && ctx.hasFilesToHide
+  (ctx.shouldHideAll || ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) &&
+  ctx.hasFilesToHide
+
+export const shouldRestoreUntrackedFiles = (ctx) => !!ctx.shouldHideAll
 
-export const applyModificationsSkipped = (ctx) => {
+export const updateIndexSkipped = (ctx) => {
   // Always apply back unstaged modifications when skipping revert or backup
   if (!ctx.shouldRevert || !ctx.shouldBackup) return false