getConfigGroups.js

/** @typedef {import('./index').Logger} Logger */

import path from 'path'

import debug from 'debug'
import objectInspect from 'object-inspect'

import { loadConfig } from './loadConfig.js'
import { ConfigNotFoundError } from './symbols.js'
import { validateConfig } from './validateConfig.js'

const debugLog = debug('lint-staged:getConfigGroups')

/**
 * Return matched files grouped by their configuration.
 *
 * @param {object} options
 * @param {Object} [options.configObject] - Explicit config object from the js API
 * @param {string} [options.configPath] - Explicit path to a config file
 * @param {string} [options.cwd] - Current working directory
 * @param {Logger} logger
 */
export const getConfigGroups = async ({ configObject, configPath, files }, logger = console) => {
  debugLog('Grouping configuration files...')

  // Return explicit config object from js API
  if (configObject) {
    debugLog('Using single direct configuration object...')
    const config = validateConfig(configObject, 'config object', logger)
    return { '': { config, files } }
  }

  // Use only explicit config path instead of discovering multiple
  if (configPath) {
    debugLog('Using single configuration path...')

    const { config, filepath } = await loadConfig({ configPath }, logger)

    if (!config) {
      logger.error(`${ConfigNotFoundError.message}.`)
      throw ConfigNotFoundError
    }

    const validatedConfig = validateConfig(config, filepath, logger)
    return { [configPath]: { config: validatedConfig, files } }
  }

  debugLog('Grouping staged files by their directories...')

  // Group files by their base directory
  const filesByDir = files.reduce((acc, file) => {
    const dir = path.normalize(path.dirname(file))

    if (dir in acc) {
      acc[dir].push(file)
    } else {
      acc[dir] = [file]
    }

    return acc
  }, {})

  debugLog('Grouped staged files into %d directories:', Object.keys(filesByDir).length)
  debugLog(objectInspect(filesByDir, { indent: 2 }))

  // Group files by their discovered config
  // { '.lintstagedrc.json': { config: {...}, files: [...] } }
  const configGroups = {}

  debugLog('Discovering config files...')

  await Promise.all(
    Object.entries(filesByDir).map(([dir, files]) => {
      // Discover config from the base directory of the file
      return loadConfig({ cwd: dir }, logger).then(({ config, filepath }) => {
        if (!config) {
          debugLog('Found no config from "%s"!', dir)
          return
        }

        if (filepath in configGroups) {
          debugLog('Found existing config "%s" from "%s"!', filepath, dir)
          // Re-use cached config and skip validation
          configGroups[filepath].files.push(...files)
          return
        }

        debugLog('Found new config "%s" from "%s"!', filepath, dir)

        const validatedConfig = validateConfig(config, filepath, logger)
        configGroups[filepath] = { config: validatedConfig, files }
      })
    })
  )

  // Throw if no configurations were found
  if (Object.keys(configGroups).length === 0) {
    debugLog('Found no config groups!')
    logger.error(`${ConfigNotFoundError.message}.`)
    throw ConfigNotFoundError
  }

  debugLog('Grouped staged files into %d groups!', Object.keys(configGroups).length)

  return configGroups
}