lint-staged 10.1.6 → 10.2.2

package/README.md

@@ -72,7 +72,9 @@ Options:
   -r, --relative                     pass relative filepaths to tasks (default: false)
   -x, --shell                        skip parsing of tasks for better shell support (default:
                                      false)
-  -h, --help                         output usage information
+  -v, --verbose                      show task output even when tasks succeed; by default only
+                                     failed output is shown (default: false)
+  -h, --help                         display help for command
 ```
 
 - **`--allow-empty`**: By default, when linter tasks undo all staged changes, lint-staged will exit with an error and abort the commit. Use this flag to allow creating empty git commits.
@@ -88,6 +90,7 @@ Options:
 - **`--quiet`**: Supress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
 - **`--shell`**: By default linter commands will be parsed for speed and security. This has the side-effect that regular shell scripts might not work as expected. You can skip parsing of commands with this option.
+- **`--verbose`**: Show task output even when tasks succeed. By default only failed output is shown.
 
 ## Configuration
 
@@ -199,7 +202,7 @@ type TaskFn = (filenames: string[]) => string | string[] | Promise<string | stri
 ```js
 // .lintstagedrc.js
 module.exports = {
-  '**/*.js?(x)': filenames => filenames.map(filename => `prettier --write '${filename}'`)
+  '**/*.js?(x)': (filenames) => filenames.map((filename) => `prettier --write '${filename}'`)
 }
 ```
 
@@ -217,7 +220,8 @@ module.exports = {
 ```js
 // .lintstagedrc.js
 module.exports = {
-  '**/*.js?(x)': filenames => (filenames.length > 10 ? 'eslint .' : `eslint ${filenames.join(' ')}`)
+  '**/*.js?(x)': (filenames) =>
+    filenames.length > 10 ? 'eslint .' : `eslint ${filenames.join(' ')}`
 }
 ```
 
@@ -228,7 +232,7 @@ module.exports = {
 const micromatch = require('micromatch')
 
 module.exports = {
-  '*': allFiles => {
+  '*': (allFiles) => {
     const match = micromatch(allFiles, ['*.js', '*.ts'])
     return `eslint ${match.join(' ')}`
   }
@@ -244,7 +248,7 @@ If for some reason you want to ignore files from the glob match, you can use `mi
 const micromatch = require('micromatch')
 
 module.exports = {
-  '*.js': files => {
+  '*.js': (files) => {
     // from `files` filter those _NOT_ matching `*test.js`
     const match = micromatch.not(files, '*test.js')
     return `eslint ${match.join(' ')}`
@@ -260,9 +264,9 @@ Please note that for most cases, globs can achieve the same effect. For the abov
 const path = require('path')
 
 module.exports = {
-  '*.ts': absolutePaths => {
+  '*.ts': (absolutePaths) => {
     const cwd = process.cwd()
-    const relativePaths = absolutePaths.map(file => path.relative(cwd, file))
+    const relativePaths = absolutePaths.map((file) => path.relative(cwd, file))
     return `ng lint myProjectName --files ${relativePaths.join(' ')}`
   }
 }
@@ -422,12 +426,17 @@ Parameters to `lintStaged` are equivalent to their CLI counterparts:
 
 ```js
 const success = await lintStaged({
+  allowEmpty: false,
+  concurrent: true,
   configPath: './path/to/configuration/file',
+  cwd: process.cwd(),
+  debug: false,
   maxArgLength: null,
-  relative: false,
-  shell: false,
   quiet: false,
-  debug: false
+  relative: false,
+  shell: false
+  stash: true,
+  verbose: false
 })
 ```
 
@@ -435,14 +444,17 @@ You can also pass config directly with `config` option:
 
 ```js
 const success = await lintStaged({
-  config: {
-    '*.js': 'eslint --fix'
-  },
+  allowEmpty: false,
+  concurrent: true,
+  config: { '*.js': 'eslint --fix' },
+  cwd: process.cwd(),
+  debug: false,
   maxArgLength: null,
+  quiet: false,
   relative: false,
   shell: false,
-  quiet: false,
-  debug: false
+  stash: true,
+  verbose: false
 })
 ```
 
@@ -518,7 +530,7 @@ const { CLIEngine } = require('eslint')
 const cli = new CLIEngine({})
 
 module.exports = {
-  '*.js': files =>
-    'eslint --max-warnings=0 ' + files.filter(file => !cli.isPathIgnored(file)).join(' ')
+  '*.js': (files) =>
+    'eslint --max-warnings=0 ' + files.filter((file) => !cli.isPathIgnored(file)).join(' ')
 }
 ```

package/bin/lint-staged.js

@@ -15,8 +15,8 @@ const pkg = require('../package.json')
 require('please-upgrade-node')(
   Object.assign({}, pkg, {
     engines: {
-      node: '>=10.13.0' // First LTS release of 'Dubnium'
-    }
+      node: '>=10.13.0', // First LTS release of 'Dubnium'
+    },
   })
 )
 
@@ -40,6 +40,11 @@ cmdline
   .option('-q, --quiet', 'disable lint-staged’s own console output', false)
   .option('-r, --relative', 'pass relative filepaths to tasks', false)
   .option('-x, --shell', 'skip parsing of tasks for better shell support', false)
+  .option(
+    '-v, --verbose',
+    'show task output even when tasks succeed; by default only failed output is shown',
+    false
+  )
   .parse(process.argv)
 
 if (cmdline.debug) {
@@ -75,7 +80,8 @@ const options = {
   stash: !!cmdline.stash, // commander inverts `no-<x>` flags to `!x`
   quiet: !!cmdline.quiet,
   relative: !!cmdline.relative,
-  shell: !!cmdline.shell
+  shell: !!cmdline.shell,
+  verbose: !!cmdline.verbose,
 }
 
 debug('Options parsed from command-line:', options)

package/lib/chunkFiles.js

@@ -33,19 +33,20 @@ function chunkArray(arr, chunkCount) {
  * @returns {Array<Array<String>>}
  */
 module.exports = function chunkFiles({ files, baseDir, maxArgLength = null, relative = false }) {
+  const normalizedFiles = files.map((file) =>
+    normalize(relative || !baseDir ? file : path.resolve(baseDir, file))
+  )
+
   if (!maxArgLength) {
     debug('Skip chunking files because of undefined maxArgLength')
-    return [files]
+    return [normalizedFiles] // wrap in an array to return a single chunk
   }
 
-  const normalizedFiles = files.map((file) =>
-    normalize(relative || !baseDir ? file : path.resolve(baseDir, file))
-  )
   const fileListLength = normalizedFiles.join(' ').length
   debug(
     `Resolved an argument string length of ${fileListLength} characters from ${normalizedFiles.length} files`
   )
   const chunkCount = Math.min(Math.ceil(fileListLength / maxArgLength), normalizedFiles.length)
   debug(`Creating ${chunkCount} chunks for maxArgLength of ${maxArgLength}`)
-  return chunkArray(files, chunkCount)
+  return chunkArray(normalizedFiles, chunkCount)
 }

package/lib/execGit.js

@@ -9,7 +9,7 @@ module.exports = async function execGit(cmd, options = {}) {
     const { stdout } = await execa('git', [].concat(cmd), {
       ...options,
       all: true,
-      cwd: options.cwd || process.cwd()
+      cwd: options.cwd || process.cwd(),
     })
     return stdout
   } catch ({ all }) {

package/lib/file.js

@@ -59,5 +59,5 @@ const writeFile = async (filename, buffer) => {
 module.exports = {
   readFile,
   unlink,
-  writeFile
+  writeFile,
 }

package/lib/generateTasks.js

@@ -21,7 +21,7 @@ module.exports = function generateTasks({
   cwd = process.cwd(),
   gitDir,
   files,
-  relative = false
+  relative = false,
 }) {
   debug('Generating linter tasks')
 
@@ -46,7 +46,7 @@ module.exports = function generateTasks({
         // If pattern doesn't look like a path, enable `matchBase` to
         // match against filenames in every directory. This makes `*.js`
         // match both `test.js` and `subdirectory/test.js`.
-        matchBase: !pattern.includes('/')
+        matchBase: !pattern.includes('/'),
       }
     ).map((file) => normalize(relative ? file : path.resolve(cwd, file)))
 

package/lib/getRenderer.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const getRenderer = ({ debug, quiet }, env = process.env) => {
+  if (quiet) return 'silent'
+  // Better support for dumb terminals: https://en.wikipedia.org/wiki/Computer_terminal#Dumb_terminals
+  const isDumbTerminal = env.TERM === 'dumb'
+  if (isDumbTerminal || env.NODE_ENV === 'test') return 'test'
+  if (debug) return 'verbose'
+  return 'update'
+}
+
+module.exports = getRenderer

package/lib/gitWorkflow.js

@@ -3,9 +3,17 @@
 const debug = require('debug')('lint-staged:git')
 const path = require('path')
 
-const chunkFiles = require('./chunkFiles')
 const execGit = require('./execGit')
 const { readFile, unlink, writeFile } = require('./file')
+const {
+  GitError,
+  RestoreOriginalStateError,
+  ApplyEmptyCommitError,
+  GetBackupStashError,
+  HideUnstagedChangesError,
+  RestoreMergeStatusError,
+  RestoreUnstagedChangesError,
+} = require('./symbols')
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
@@ -43,25 +51,25 @@ const GIT_DIFF_ARGS = [
   '--no-ext-diff', // disable external diff tools for consistent behaviour
   '--src-prefix=a/', // force prefix for consistent behaviour
   '--dst-prefix=b/', // force prefix for consistent behaviour
-  '--patch' // output a patch that can be applied
+  '--patch', // output a patch that can be applied
 ]
 const GIT_APPLY_ARGS = ['-v', '--whitespace=nowarn', '--recount', '--unidiff-zero']
 
-const handleError = (error, ctx) => {
-  ctx.gitError = true
+const handleError = (error, ctx, symbol) => {
+  ctx.errors.add(GitError)
+  if (symbol) ctx.errors.add(symbol)
   throw error
 }
 
 class GitWorkflow {
-  constructor({ allowEmpty, gitConfigDir, gitDir, matchedFiles, maxArgLength }) {
+  constructor({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
     this.deletedFiles = []
     this.gitConfigDir = gitConfigDir
     this.gitDir = gitDir
     this.unstagedDiff = null
     this.allowEmpty = allowEmpty
-    this.matchedFiles = matchedFiles
-    this.maxArgLength = maxArgLength
+    this.matchedFileChunks = matchedFileChunks
 
     /**
      * These three files hold state about an ongoing git merge
@@ -87,7 +95,7 @@ class GitWorkflow {
     const stashes = await this.execGit(['stash', 'list'])
     const index = stashes.split('\n').findIndex((line) => line.includes(STASH))
     if (index === -1) {
-      ctx.gitGetBackupStashError = true
+      ctx.errors.add(GetBackupStashError)
       throw new Error('lint-staged automatic backup is missing!')
     }
     return `stash@{${index}}`
@@ -115,7 +123,7 @@ class GitWorkflow {
     await Promise.all([
       readFile(this.mergeHeadFilename).then((buffer) => (this.mergeHeadBuffer = buffer)),
       readFile(this.mergeModeFilename).then((buffer) => (this.mergeModeBuffer = buffer)),
-      readFile(this.mergeMsgFilename).then((buffer) => (this.mergeMsgBuffer = buffer))
+      readFile(this.mergeMsgFilename).then((buffer) => (this.mergeMsgBuffer = buffer)),
     ])
     debug('Done backing up merge state!')
   }
@@ -123,19 +131,23 @@ class GitWorkflow {
   /**
    * Restore meta information about ongoing git merge
    */
-  async restoreMergeStatus() {
+  async restoreMergeStatus(ctx) {
     debug('Restoring merge state...')
     try {
       await Promise.all([
         this.mergeHeadBuffer && writeFile(this.mergeHeadFilename, this.mergeHeadBuffer),
         this.mergeModeBuffer && writeFile(this.mergeModeFilename, this.mergeModeBuffer),
-        this.mergeMsgBuffer && writeFile(this.mergeMsgFilename, this.mergeMsgBuffer)
+        this.mergeMsgBuffer && writeFile(this.mergeMsgFilename, this.mergeMsgBuffer),
       ])
       debug('Done restoring merge state!')
     } catch (error) {
       debug('Failed restoring merge state with error:')
       debug(error)
-      throw new Error('Merge state could not be restored due to an error!')
+      handleError(
+        new Error('Merge state could not be restored due to an error!'),
+        ctx,
+        RestoreMergeStatusError
+      )
     }
   }
 
@@ -159,6 +171,7 @@ class GitWorkflow {
         return index !== ' ' && workingTree !== ' ' && index !== '?' && workingTree !== '?'
       })
       .map((line) => line.substr(3)) // Remove first three letters (index, workingTree, and a whitespace)
+      .filter(Boolean) // Filter empty string
     debug('Found partially staged files:', partiallyStaged)
     return partiallyStaged.length ? partiallyStaged : null
   }
@@ -166,7 +179,7 @@ class GitWorkflow {
   /**
    * Create a diff of partially staged files and backup stash if enabled.
    */
-  async prepare(ctx, shouldBackup) {
+  async prepare(ctx) {
     try {
       debug('Backing up original state...')
 
@@ -179,31 +192,28 @@ class GitWorkflow {
         const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
         const files = processRenames(this.partiallyStagedFiles)
         await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
+      } else {
+        ctx.hasPartiallyStagedFiles = false
       }
 
       /**
        * If backup stash should be skipped, no need to continue
        */
-      if (!shouldBackup) return
+      if (!ctx.shouldBackup) return
+
+      // 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 `--keep-index` flag resurrects deleted files
+      // - 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()
 
-      // the `git stash` clears metadata about a possible git merge
-      // Manually check and backup if necessary
-      await this.backupMergeStatus()
-
-      // Save stash of original state
-      await this.execGit(['stash', 'save', STASH])
-      await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash()])
-
-      // Restore meta information about ongoing git merge, cleared by `git stash`
-      await this.restoreMergeStatus()
-
-      // If stashing resurrected deleted files, clean them out
-      await Promise.all(this.deletedFiles.map((file) => unlink(file)))
+      // 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 hash = await this.execGit(['stash', 'create'])
+      await this.execGit(['stash', 'store', '--quiet', '--message', STASH, hash])
 
       debug('Done backing up original state!')
     } catch (error) {
@@ -223,8 +233,7 @@ class GitWorkflow {
        * `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
        * If this does fail, the handleError method will set ctx.gitError and lint-staged will fail.
        */
-      ctx.gitHideUnstagedChangesError = true
-      handleError(error, ctx)
+      handleError(error, ctx, HideUnstagedChangesError)
     }
   }
 
@@ -234,19 +243,12 @@ class GitWorkflow {
    */
   async applyModifications(ctx) {
     debug('Adding task modifications to index...')
-    // `matchedFiles` 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.
-    const files = Array.from(this.matchedFiles)
-    // Chunk files for better Windows compatibility
-    const matchedFileChunks = chunkFiles({
-      baseDir: this.gitDir,
-      files,
-      maxArgLength: this.maxArgLength
-    })
 
+    // `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 matchedFileChunks) {
+    for (const files of this.matchedFileChunks) {
       await this.execGit(['add', '--', ...files])
     }
 
@@ -256,8 +258,7 @@ class GitWorkflow {
     if (!stagedFilesAfterAdd && !this.allowEmpty) {
       // Tasks reverted all staged changes and the commit would be empty
       // Throw error to stop commit unless `--allow-empty` was used
-      ctx.gitApplyEmptyCommitError = true
-      handleError(new Error('Prevented an empty git commit!'), ctx)
+      handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
     }
   }
 
@@ -281,10 +282,10 @@ class GitWorkflow {
       } catch (threeWayApplyError) {
         debug('Error while restoring unstaged changes using 3-way merge:')
         debug(threeWayApplyError)
-        ctx.gitRestoreUnstagedChangesError = true
         handleError(
           new Error('Unstaged changes could not be restored due to a merge conflict!'),
-          ctx
+          ctx,
+          RestoreUnstagedChangesError
         )
       }
     }
@@ -300,7 +301,7 @@ class GitWorkflow {
       await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash(ctx)])
 
       // Restore meta information about ongoing git merge
-      await this.restoreMergeStatus()
+      await this.restoreMergeStatus(ctx)
 
       // If stashing resurrected deleted files, clean them out
       await Promise.all(this.deletedFiles.map((file) => unlink(file)))
@@ -310,8 +311,7 @@ class GitWorkflow {
 
       debug('Done restoring original state!')
     } catch (error) {
-      ctx.gitRestoreOriginalStateError = true
-      handleError(error, ctx)
+      handleError(error, ctx, RestoreOriginalStateError)
     }
   }
 

package/lib/index.js

@@ -2,13 +2,15 @@
 
 const dedent = require('dedent')
 const { cosmiconfig } = require('cosmiconfig')
+const debugLog = require('debug')('lint-staged')
 const stringifyObject = require('stringify-object')
-const printErrors = require('./printErrors')
+
+const { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } = require('./messages')
+const printTaskOutput = require('./printTaskOutput')
 const runAll = require('./runAll')
+const { ApplyEmptyCommitError, GetBackupStashError, GitError } = require('./symbols')
 const validateConfig = require('./validateConfig')
 
-const debugLog = require('debug')('lint-staged')
-
 const errConfigNotFound = new Error('Config could not be found')
 
 function resolveConfig(configPath) {
@@ -28,8 +30,8 @@ function loadConfig(configPath) {
       '.lintstagedrc.yaml',
       '.lintstagedrc.yml',
       '.lintstagedrc.js',
-      'lint-staged.config.js'
-    ]
+      'lint-staged.config.js',
+    ],
   })
 
   return configPath ? explorer.load(resolveConfig(configPath)) : explorer.search()
@@ -46,12 +48,14 @@ function loadConfig(configPath) {
  * @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
+ * @param {Object} [options.cwd] - Current working directory
  * @param {boolean} [options.debug] - Enable debug mode
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
  * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
+ * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} [logger]
  *
  * @returns {Promise<boolean>} Promise of whether the linting passed or failed
@@ -62,12 +66,14 @@ module.exports = async function lintStaged(
     concurrent = true,
     config: configObject,
     configPath,
+    cwd = process.cwd(),
     debug = false,
     maxArgLength,
     quiet = false,
     relative = false,
     shell = false,
-    stash = true
+    stash = true,
+    verbose = false,
   } = {},
   logger = console
 ) {
@@ -98,14 +104,38 @@ module.exports = async function lintStaged(
     delete process.env.GIT_LITERAL_PATHSPECS
 
     try {
-      await runAll(
-        { allowEmpty, concurrent, config, debug, maxArgLength, stash, quiet, relative, shell },
+      const ctx = await runAll(
+        {
+          allowEmpty,
+          concurrent,
+          config,
+          cwd,
+          debug,
+          maxArgLength,
+          quiet,
+          relative,
+          shell,
+          stash,
+          verbose,
+        },
         logger
       )
-      debugLog('tasks were executed successfully!')
+      debugLog('Tasks were executed successfully!')
+      printTaskOutput(ctx, logger)
       return true
     } catch (runAllError) {
-      printErrors(runAllError, logger)
+      const { ctx } = runAllError
+      if (ctx.errors.has(ApplyEmptyCommitError)) {
+        logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
+        logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(RESTORE_STASH_EXAMPLE)
+        }
+      }
+
+      printTaskOutput(ctx, logger)
       return false
     }
   } catch (lintStagedError) {

package/lib/makeCmdTasks.js

@@ -13,8 +13,9 @@ const debug = require('debug')('lint-staged:make-cmd-tasks')
  * @param {Array<string>} options.files
  * @param {string} options.gitDir
  * @param {Boolean} shell
+ * @param {Boolean} verbose
  */
-module.exports = async function makeCmdTasks({ commands, files, gitDir, shell }) {
+module.exports = async function makeCmdTasks({ commands, files, gitDir, shell, verbose }) {
   debug('Creating listr tasks for commands %o', commands)
   const commandArray = Array.isArray(commands) ? commands : [commands]
   const cmdTasks = []
@@ -49,7 +50,7 @@ module.exports = async function makeCmdTasks({ commands, files, gitDir, shell })
       cmdTasks.push({
         title,
         command,
-        task: resolveTaskFn({ command, files, gitDir, isFn, shell })
+        task: resolveTaskFn({ command, files, gitDir, isFn, shell, verbose }),
       })
     }
   }

package/lib/messages.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const chalk = require('chalk')
+const { error, info, warning } = require('log-symbols')
+
+const NOT_GIT_REPO = chalk.redBright(`${error} Current directory is not a git directory!`)
+
+const FAILED_GET_STAGED_FILES = chalk.redBright(`${error} Failed to get staged files!`)
+
+const NO_STAGED_FILES = `${info} No staged files found.`
+
+const NO_TASKS = `${info} No staged files match any configured task.`
+
+const skippingBackup = (hasInitialCommit) => {
+  const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
+  return `${warning} ${chalk.yellow(`Skipping backup because ${reason}.\n`)}`
+}
+
+const DEPRECATED_GIT_ADD = `${warning} ${chalk.yellow(
+  `Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.`
+)}
+`
+
+const TASK_ERROR = 'Skipped because of errors from tasks.'
+
+const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+
+const GIT_ERROR = `\n  ${error} ${chalk.red(`lint-staged failed due to a git error.`)}`
+
+const PREVENTED_EMPTY_COMMIT = `
+  ${warning} ${chalk.yellow(`lint-staged prevented an empty git commit.
+  Use the --allow-empty option to continue, or check your task configuration`)}
+`
+
+const RESTORE_STASH_EXAMPLE = `  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}
+`
+
+module.exports = {
+  NOT_GIT_REPO,
+  FAILED_GET_STAGED_FILES,
+  NO_STAGED_FILES,
+  NO_TASKS,
+  skippingBackup,
+  DEPRECATED_GIT_ADD,
+  TASK_ERROR,
+  SKIPPED_GIT_ERROR,
+  GIT_ERROR,
+  PREVENTED_EMPTY_COMMIT,
+  RESTORE_STASH_EXAMPLE,
+}

package/lib/printTaskOutput.js

@@ -0,0 +1,16 @@
+'use strict'
+
+/**
+ * Handle logging of listr `ctx.output` to the specified `logger`
+ * @param {Object} ctx - The listr initial state
+ * @param {Object} logger - The logger
+ */
+const printTaskOutput = (ctx = {}, logger) => {
+  if (!Array.isArray(ctx.output)) return
+  const log = ctx.errors && ctx.errors.size > 0 ? logger.error : logger.log
+  for (const line of ctx.output) {
+    log(line)
+  }
+}
+
+module.exports = printTaskOutput

package/lib/resolveTaskFn.js

@@ -1,57 +1,66 @@
 'use strict'
 
-const chalk = require('chalk')
-const { parseArgsStringToArgv } = require('string-argv')
-const dedent = require('dedent')
+const { redBright, dim } = require('chalk')
 const execa = require('execa')
-const symbols = require('log-symbols')
-
 const debug = require('debug')('lint-staged:task')
+const { parseArgsStringToArgv } = require('string-argv')
+const { error, info } = require('log-symbols')
+
+const { getInitialState } = require('./state')
+const { TaskError } = require('./symbols')
 
-const successMsg = (linter) => `${symbols.success} ${linter} passed!`
+const getTag = ({ code, killed, signal }) => signal || (killed && 'KILLED') || code || 'FAILED'
 
 /**
- * Create and returns an error instance with a given message.
- * If we set the message on the error instance, it gets logged multiple times(see #142).
- * So we set the actual error message in a private field and extract it later,
- * log only once.
+ * Handle task console output.
  *
- * @param {string} message
+ * @param {string} command
+ * @param {Object} result
+ * @param {string} result.stdout
+ * @param {string} result.stderr
+ * @param {boolean} result.failed
+ * @param {boolean} result.killed
+ * @param {string} result.signal
+ * @param {Object} ctx
  * @returns {Error}
  */
-function throwError(message) {
-  const err = new Error()
-  err.privateMsg = `\n\n\n${message}`
-  return err
+const handleOutput = (command, result, ctx, isError = false) => {
+  const { stderr, stdout } = result
+  const hasOutput = !!stderr || !!stdout
+
+  if (hasOutput) {
+    const outputTitle = isError ? redBright(`${error} ${command}:`) : `${info} ${command}:`
+    const output = []
+      .concat(ctx.quiet ? [] : ['', outputTitle])
+      .concat(stderr ? stderr : [])
+      .concat(stdout ? stdout : [])
+    ctx.output.push(output.join('\n'))
+  } else if (isError) {
+    // Show generic error when task had no output
+    const tag = getTag(result)
+    const message = redBright(`\n${error} ${command} failed without output (${tag}).`)
+    if (!ctx.quiet) ctx.output.push(message)
+  }
 }
 
 /**
- * Create a failure message dependding on process result.
+ * Create a error output dependding on process result.
  *
- * @param {string} linter
+ * @param {string} command
  * @param {Object} result
  * @param {string} result.stdout
  * @param {string} result.stderr
  * @param {boolean} result.failed
  * @param {boolean} result.killed
  * @param {string} result.signal
- * @param {Object} context (see https://github.com/SamVerschueren/listr#context)
+ * @param {Object} ctx
  * @returns {Error}
  */
-function makeErr(linter, result, context = {}) {
-  context.taskError = true
-  const { stdout, stderr, killed, signal } = result
-  if (killed || (signal && signal !== '')) {
-    return throwError(
-      `${symbols.warning} ${chalk.yellow(`${linter} was terminated with ${signal}`)}`
-    )
-  }
-  return throwError(dedent`${symbols.error} ${chalk.redBright(
-    `${linter} found some errors. Please fix them and try committing again.`
-  )}
-  ${stdout}
-  ${stderr}
-  `)
+const makeErr = (command, result, ctx) => {
+  ctx.errors.add(TaskError)
+  handleOutput(command, result, ctx, true)
+  const tag = getTag(result)
+  return new Error(`${redBright(command)} ${dim(`[${tag}]`)}`)
 }
 
 /**
@@ -64,9 +73,18 @@ function makeErr(linter, result, context = {}) {
  * @param {Array<string>} options.files — Filepaths to run the linter task against
  * @param {Boolean} [options.relative] — Whether the filepaths should be relative
  * @param {Boolean} [options.shell] — Whether to skip parsing linter task for better shell support
+ * @param {Boolean} [options.verbose] — Always show task verbose
  * @returns {function(): Promise<Array<string>>}
  */
-module.exports = function resolveTaskFn({ command, files, gitDir, isFn, relative, shell = false }) {
+module.exports = function resolveTaskFn({
+  command,
+  files,
+  gitDir,
+  isFn,
+  relative,
+  shell = false,
+  verbose = false,
+}) {
   const [cmd, ...args] = parseArgsStringToArgv(command)
   debug('cmd:', cmd)
   debug('args:', args)
@@ -81,16 +99,17 @@ module.exports = function resolveTaskFn({ command, files, gitDir, isFn, relative
   }
   debug('execaOptions:', execaOptions)
 
-  return async (ctx) => {
-    const promise = shell
+  return async (ctx = getInitialState()) => {
+    const result = await (shell
       ? execa.command(isFn ? command : `${command} ${files.join(' ')}`, execaOptions)
-      : execa(cmd, isFn ? args : args.concat(files), execaOptions)
-    const result = await promise
+      : execa(cmd, isFn ? args : args.concat(files), execaOptions))
 
     if (result.failed || result.killed || result.signal != null) {
-      throw makeErr(cmd, result, ctx)
+      throw makeErr(command, result, ctx)
     }
 
-    return successMsg(cmd)
+    if (verbose) {
+      handleOutput(command, result, ctx)
+    }
   }
 }

package/lib/runAll.js

@@ -2,61 +2,39 @@
 
 /** @typedef {import('./index').Logger} Logger */
 
-const chalk = require('chalk')
-const Listr = require('listr')
-const symbols = require('log-symbols')
+const { Listr } = require('listr2')
 
 const chunkFiles = require('./chunkFiles')
+const debugLog = require('debug')('lint-staged:run')
 const execGit = require('./execGit')
 const generateTasks = require('./generateTasks')
+const getRenderer = require('./getRenderer')
 const getStagedFiles = require('./getStagedFiles')
 const GitWorkflow = require('./gitWorkflow')
 const makeCmdTasks = require('./makeCmdTasks')
+const {
+  DEPRECATED_GIT_ADD,
+  FAILED_GET_STAGED_FILES,
+  NOT_GIT_REPO,
+  NO_STAGED_FILES,
+  NO_TASKS,
+  SKIPPED_GIT_ERROR,
+  skippingBackup,
+} = require('./messages')
 const resolveGitRepo = require('./resolveGitRepo')
-
-const debugLog = require('debug')('lint-staged:run')
-
-const getRenderer = ({ debug, quiet }) => {
-  if (quiet) return 'silent'
-  // Better support for dumb terminals: https://en.wikipedia.org/wiki/Computer_terminal#Dumb_terminals
-  const isDumbTerminal = process.env.TERM === 'dumb'
-  if (debug || isDumbTerminal) return 'verbose'
-  return 'update'
-}
-
-const MESSAGES = {
-  TASK_ERROR: 'Skipped because of errors from tasks.',
-  GIT_ERROR: 'Skipped because of previous git error.'
-}
-
-const shouldSkipApplyModifications = (ctx) => {
-  // Should be skipped in case of git errors
-  if (ctx.gitError) {
-    return MESSAGES.GIT_ERROR
-  }
-  // Should be skipped when tasks fail
-  if (ctx.taskError) {
-    return MESSAGES.TASK_ERROR
-  }
-}
-
-const shouldSkipRevert = (ctx) => {
-  // Should be skipped in case of unknown git errors
-  if (ctx.gitError && !ctx.gitApplyEmptyCommitError && !ctx.gitRestoreUnstagedChangesError) {
-    return MESSAGES.GIT_ERROR
-  }
-}
-
-const shouldSkipCleanup = (ctx) => {
-  // Should be skipped in case of unknown git errors
-  if (ctx.gitError && !ctx.gitApplyEmptyCommitError && !ctx.gitRestoreUnstagedChangesError) {
-    return MESSAGES.GIT_ERROR
-  }
-  // Should be skipped when reverting to original state fails
-  if (ctx.gitRestoreOriginalStateError) {
-    return MESSAGES.GIT_ERROR
-  }
-}
+const {
+  applyModificationsSkipped,
+  cleanupEnabled,
+  cleanupSkipped,
+  getInitialState,
+  hasPartiallyStagedFiles,
+  restoreOriginalStateEnabled,
+  restoreOriginalStateSkipped,
+  restoreUnstagedChangesSkipped,
+} = require('./state')
+const { GitRepoError, GetStagedFilesError, GitError } = require('./symbols')
+
+const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ctx })
 
 /**
  * Executes all tasks and either resolves or rejects the promise
@@ -72,6 +50,7 @@ const shouldSkipCleanup = (ctx) => {
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
  * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
+ * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} logger
  * @returns {Promise}
  */
@@ -86,14 +65,21 @@ const runAll = async (
     quiet = false,
     relative = false,
     shell = false,
-    stash = true
+    stash = true,
+    verbose = false,
   },
   logger = console
 ) => {
   debugLog('Running all linter scripts')
 
+  const ctx = getInitialState({ quiet })
+
   const { gitDir, gitConfigDir } = await resolveGitRepo(cwd)
-  if (!gitDir) throw new Error('Current directory is not a git directory!')
+  if (!gitDir) {
+    if (!quiet) ctx.output.push(NOT_GIT_REPO)
+    ctx.errors.add(GitRepoError)
+    throw createError(ctx)
+  }
 
   // Test whether we have any commits or not.
   // Stashing must be disabled with no initial commit.
@@ -102,19 +88,23 @@ const runAll = async (
     .catch(() => false)
 
   // Lint-staged should create a backup stash only when there's an initial commit
-  const shouldBackup = hasInitialCommit && stash
-  if (!shouldBackup) {
-    const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
-    logger.warn(`${symbols.warning} ${chalk.yellow(`Skipping backup because ${reason}.\n`)}`)
+  ctx.shouldBackup = hasInitialCommit && stash
+  if (!ctx.shouldBackup) {
+    logger.warn(skippingBackup(hasInitialCommit))
   }
 
   const files = await getStagedFiles({ cwd: gitDir })
-  if (!files) throw new Error('Unable to get staged files!')
+  if (!files) {
+    if (!quiet) ctx.output.push(FAILED_GET_STAGED_FILES)
+    ctx.errors.add(GetStagedFilesError)
+    throw createError(ctx, GetStagedFilesError)
+  }
   debugLog('Loaded list of staged files in git:\n%O', files)
 
   // If there are no files avoid executing any lint-staged logic
   if (files.length === 0) {
-    return logger.log(`${symbols.info} No staged files found.`)
+    if (!quiet) ctx.output.push(NO_STAGED_FILES)
+    return ctx
   }
 
   const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
@@ -126,9 +116,10 @@ const runAll = async (
   let hasDeprecatedGitAdd = false
 
   const listrOptions = {
+    ctx,
     dateFormat: false,
     exitOnError: false,
-    renderer: getRenderer({ debug, quiet })
+    renderer: getRenderer({ debug, quiet }),
   }
 
   const listrTasks = []
@@ -145,7 +136,8 @@ const runAll = async (
         commands: task.commands,
         files: task.fileList,
         gitDir,
-        shell
+        shell,
+        verbose,
       })
 
       // Add files from task to match set
@@ -161,9 +153,9 @@ const runAll = async (
           new Listr(subTasks, {
             // In sub-tasks we don't want to run concurrently
             // and we want to abort on errors
-            dateFormat: false,
+            ...listrOptions,
             concurrent: false,
-            exitOnError: true
+            exitOnError: true,
           }),
         skip: () => {
           // Skip task when no files matched
@@ -171,7 +163,7 @@ const runAll = async (
             return `No staged files match ${task.pattern}`
           }
           return false
-        }
+        },
       })
     }
 
@@ -180,103 +172,84 @@ const runAll = async (
       title:
         chunkCount > 1 ? `Running tasks (chunk ${index + 1}/${chunkCount})...` : 'Running tasks...',
       task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent }),
-      skip: (ctx = {}) => {
+      skip: () => {
         // Skip if the first step (backup) failed
-        if (ctx.gitError) return MESSAGES.GIT_ERROR
+        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 'No tasks to run.'
         return false
-      }
+      },
     })
   }
 
   if (hasDeprecatedGitAdd) {
-    logger.warn(`${symbols.warning} ${chalk.yellow(
-      `Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.`
-    )}
-`)
+    logger.warn(DEPRECATED_GIT_ADD)
   }
 
   // If all of the configured tasks should be skipped
   // avoid executing any lint-staged logic
   if (listrTasks.every((task) => task.skip())) {
-    logger.log('No staged files match any of provided globs.')
-    return 'No tasks to run.'
+    if (!quiet) ctx.output.push(NO_TASKS)
+    return ctx
   }
 
-  const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, matchedFiles, maxArgLength })
+  // Chunk matched files for better Windows compatibility
+  const matchedFileChunks = chunkFiles({
+    // matched files are relative to `cwd`, not `gitDir`, when `relative` is used
+    baseDir: cwd,
+    files: Array.from(matchedFiles),
+    maxArgLength,
+    relative: false,
+  })
+
+  const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks })
 
   const runner = new Listr(
     [
       {
         title: 'Preparing...',
-        task: (ctx) => git.prepare(ctx, shouldBackup)
+        task: (ctx) => git.prepare(ctx),
       },
       {
         title: 'Hiding unstaged changes to partially staged files...',
         task: (ctx) => git.hideUnstagedChanges(ctx),
-        enabled: (ctx) => ctx.hasPartiallyStagedFiles
+        enabled: hasPartiallyStagedFiles,
       },
       ...listrTasks,
       {
         title: 'Applying modifications...',
         task: (ctx) => git.applyModifications(ctx),
-        // Always apply back unstaged modifications when skipping backup
-        skip: (ctx) => shouldBackup && shouldSkipApplyModifications(ctx)
+        skip: applyModificationsSkipped,
       },
       {
         title: 'Restoring unstaged changes to partially staged files...',
         task: (ctx) => git.restoreUnstagedChanges(ctx),
-        enabled: (ctx) => ctx.hasPartiallyStagedFiles,
-        skip: shouldSkipApplyModifications
+        enabled: hasPartiallyStagedFiles,
+        skip: restoreUnstagedChangesSkipped,
       },
       {
         title: 'Reverting to original state because of errors...',
         task: (ctx) => git.restoreOriginalState(ctx),
-        enabled: (ctx) =>
-          shouldBackup &&
-          (ctx.taskError || ctx.gitApplyEmptyCommitError || ctx.gitRestoreUnstagedChangesError),
-        skip: shouldSkipRevert
+        enabled: restoreOriginalStateEnabled,
+        skip: restoreOriginalStateSkipped,
       },
       {
         title: 'Cleaning up...',
         task: (ctx) => git.cleanup(ctx),
-        enabled: () => shouldBackup,
-        skip: shouldSkipCleanup
-      }
+        enabled: cleanupEnabled,
+        skip: cleanupSkipped,
+      },
     ],
     listrOptions
   )
 
-  try {
-    await runner.run({})
-  } catch (error) {
-    if (error.context.gitApplyEmptyCommitError) {
-      logger.warn(`
-  ${symbols.warning} ${chalk.yellow(`lint-staged prevented an empty git commit.
-    Use the --allow-empty option to continue, or check your task configuration`)}
-`)
-    } else if (error.context.gitError && !error.context.gitGetBackupStashError) {
-      logger.error(`\n  ${symbols.error} ${chalk.red(`lint-staged failed due to a git error.`)}`)
-
-      if (shouldBackup) {
-        // No sense to show this if the backup stash itself is missing.
-        logger.error(`  Any lost modifications can be restored from a git stash:
-
-    > git stash list
-    stash@{0}: On master: automatic lint-staged backup
-    > git stash apply --index stash@{0}\n`)
-      }
-    }
+  await runner.run()
 
-    throw error
+  if (ctx.errors.size > 0) {
+    throw createError(ctx)
   }
+
+  return ctx
 }
 
 module.exports = runAll
-
-module.exports.shouldSkip = {
-  shouldSkipApplyModifications,
-  shouldSkipRevert,
-  shouldSkipCleanup
-}

package/lib/state.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const { GIT_ERROR, TASK_ERROR } = require('./messages')
+const {
+  ApplyEmptyCommitError,
+  TaskError,
+  RestoreOriginalStateError,
+  GitError,
+  RestoreUnstagedChangesError,
+} = require('./symbols')
+
+const getInitialState = ({ quiet = false } = {}) => ({
+  hasPartiallyStagedFiles: null,
+  shouldBackup: null,
+  errors: new Set([]),
+  output: [],
+  quiet,
+})
+
+const hasPartiallyStagedFiles = (ctx) => ctx.hasPartiallyStagedFiles
+
+const applyModificationsSkipped = (ctx) => {
+  // Always apply back unstaged modifications when skipping backup
+  if (!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
+  }
+}
+
+const restoreUnstagedChangesSkipped = (ctx) => {
+  // 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
+  }
+}
+
+const restoreOriginalStateEnabled = (ctx) =>
+  ctx.shouldBackup &&
+  (ctx.errors.has(TaskError) ||
+    ctx.errors.has(ApplyEmptyCommitError) ||
+    ctx.errors.has(RestoreUnstagedChangesError))
+
+const restoreOriginalStateSkipped = (ctx) => {
+  // Should be skipped in case of unknown git errors
+  if (
+    ctx.errors.has(GitError) &&
+    !ctx.errors.has(ApplyEmptyCommitError) &&
+    !ctx.errors.has(RestoreUnstagedChangesError)
+  ) {
+    return GIT_ERROR
+  }
+}
+
+const cleanupEnabled = (ctx) => ctx.shouldBackup
+
+const cleanupSkipped = (ctx) => {
+  // Should be skipped in case of unknown git errors
+  if (
+    ctx.errors.has(GitError) &&
+    !ctx.errors.has(ApplyEmptyCommitError) &&
+    !ctx.errors.has(RestoreUnstagedChangesError)
+  ) {
+    return GIT_ERROR
+  }
+  // Should be skipped when reverting to original state fails
+  if (ctx.errors.has(RestoreOriginalStateError)) {
+    return GIT_ERROR
+  }
+}
+
+module.exports = {
+  getInitialState,
+  hasPartiallyStagedFiles,
+  applyModificationsSkipped,
+  restoreUnstagedChangesSkipped,
+  restoreOriginalStateEnabled,
+  restoreOriginalStateSkipped,
+  cleanupEnabled,
+  cleanupSkipped,
+}

package/lib/symbols.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const ApplyEmptyCommitError = Symbol('ApplyEmptyCommitError')
+const GetBackupStashError = Symbol('GetBackupStashError')
+const GetStagedFilesError = Symbol('GetStagedFilesError')
+const GitError = Symbol('GitError')
+const GitRepoError = Symbol('GitRepoError')
+const HideUnstagedChangesError = Symbol('HideUnstagedChangesError')
+const RestoreMergeStatusError = Symbol('RestoreMergeStatusError')
+const RestoreOriginalStateError = Symbol('RestoreOriginalStateError')
+const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
+const TaskError = Symbol('TaskError')
+
+module.exports = {
+  ApplyEmptyCommitError,
+  GetBackupStashError,
+  GetStagedFilesError,
+  GitError,
+  GitRepoError,
+  HideUnstagedChangesError,
+  RestoreMergeStatusError,
+  RestoreOriginalStateError,
+  RestoreUnstagedChangesError,
+  TaskError,
+}

package/lib/validateConfig.js

@@ -15,7 +15,7 @@ const TEST_DEPRECATED_KEYS = new Map([
   ['ignore', (key) => Array.isArray(key)],
   ['subTaskConcurrency', (key) => typeof key === 'number'],
   ['renderer', (key) => typeof key === 'string'],
-  ['relative', (key) => typeof key === 'boolean']
+  ['relative', (key) => typeof key === 'boolean'],
 ])
 
 const formatError = (helpMsg) => `● Validation Error:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "10.1.6",
+  "version": "10.2.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",
@@ -21,9 +21,7 @@
   ],
   "scripts": {
     "cz": "git-cz",
-    "lint:base": "eslint --rule \"prettier/prettier: 2\"",
-    "lint": "npm run lint:base -- .",
-    "lint:fix": "npm run lint -- --fix",
+    "lint": "eslint .",
     "pretest": "npm run lint",
     "test": "jest --coverage",
     "test:watch": "jest --watch"
@@ -40,7 +38,7 @@
     "debug": "^4.1.1",
     "dedent": "^0.7.0",
     "execa": "^4.0.0",
-    "listr": "^0.14.3",
+    "listr2": "1.3.8",
     "log-symbols": "^3.0.0",
     "micromatch": "^4.0.2",
     "normalize-path": "^3.0.0",
@@ -52,18 +50,14 @@
     "@babel/core": "^7.9.0",
     "@babel/plugin-proposal-object-rest-spread": "^7.9.5",
     "@babel/preset-env": "^7.9.5",
-    "babel-eslint": "^10.1.0",
+    "babel-eslint": "10.1.0",
     "babel-jest": "^25.3.0",
     "consolemock": "^1.1.0",
     "eslint": "^6.8.0",
-    "eslint-config-okonet": "^7.0.2",
     "eslint-config-prettier": "^6.10.1",
-    "eslint-plugin-flowtype": "^4.7.0",
     "eslint-plugin-import": "^2.20.2",
-    "eslint-plugin-jsx-a11y": "^6.2.3",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^3.1.3",
-    "eslint-plugin-react": "^7.19.0",
     "fs-extra": "^9.0.0",
     "husky": "^4.2.5",
     "jest": "^25.3.0",

package/lib/printErrors.js

@@ -1,15 +0,0 @@
-'use strict'
-
-// istanbul ignore next
-// Work-around for duplicated error logs, see #142
-const errMsg = (err) => (err.privateMsg != null ? err.privateMsg : err.message)
-
-module.exports = function printErrors(errorInstance, logger) {
-  if (Array.isArray(errorInstance.errors)) {
-    errorInstance.errors.forEach((lintError) => {
-      logger.error(errMsg(lintError))
-    })
-  } else {
-    logger.error(errMsg(errorInstance))
-  }
-}