@alexlit/lint-kit 186.2.2 → 186.3.0

package/packages/config-stylelint/node_modules/lint-staged/src/calcChunkSize.js

@@ -1,42 +0,0 @@
-'use strict'
-
-/**
- * Calculates and returns the chunk size for given file paths and `chunkSize`
- * option.
- *
- * It returns the minimum of the following:
- *
- *  - Total number of files
- *  - Max allowed chunk size so that command length does not exceed the system
- *    limitation on windows
- *  - User specified chunk size or the default
- *
- * Worked example:
- * **Assumption** - Our max file path length is 100, Hence max allowed chunk
- * size is 80
- *
- *  - Case 1: Only 10 files are there, chunk size should be 10 only
- *  - Case 2: There are 100 files and user has overridden the option with
- *    chunk size 40. So chunk size should be 40
- *  - Case 3: There are 100 files and user has overridden the option with
- *    chunk size 100. So chunk size should be 80
- *
- * @param {Array<string>} paths The array of file paths
- * @param {number} idealChunkSize User specified / default chunk size
- * @returns {number} The chunk size
- */
-module.exports = function calcChunkSize(paths, idealChunkSize) {
-  /* What is the longest file path? */
-  const maxPathLen = paths.reduce(
-    (maxLen, filePath) => Math.max(maxLen, filePath.length),
-    20 // safe initial value
-  )
-
-  /* In the worst case scenario, */
-  /* how many files can we process in a single command? */
-  /* For windows systems, command length is limited to 8192 */
-  const maxAllowedChunkSize = Math.floor(8000 / maxPathLen)
-
-  /* Configured chunk size / default - idealChunkSize */
-  return Math.min(paths.length, maxAllowedChunkSize, idealChunkSize)
-}

package/packages/config-stylelint/node_modules/lint-staged/src/checkPkgScripts.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const chalk = require('chalk')
-const dedent = require('dedent')
-const has = require('lodash/has')
-
-const warn = msg => {
-  console.warn(chalk.yellowBright.bold(msg))
-}
-
-/**
- * Checks if the given command or binary name is present in the package.json scripts. This would be
- * called if and when resolving a binary fails in `findBin`.
- *
- * @param {Object} pkg package.json
- * @param {string} cmd
- * @param {string} binName
- * @param {Array<string>} args
- * @throws {Error} If a script is found in the pkg for the given `cmd` or `binName`.
- */
-module.exports = function checkPkgScripts(pkg, cmd, binName, args) {
-  if (pkg && pkg.scripts) {
-    const { scripts } = pkg
-    let scriptName
-    let script
-    if (has(scripts, cmd)) {
-      scriptName = cmd
-      script = scripts[cmd]
-    } else if (has(scripts, binName)) {
-      scriptName = binName
-      script = scripts[binName]
-    } else {
-      return
-    }
-
-    const argsStr = args && args.length ? args.join(' ') : ''
-    warn(dedent`
-      \`lint-staged\` no longer supports running scripts defined in package.json.
-
-      The same behavior can be achieved by changing the command to any of the following:
-        - \`npm run ${scriptName} -- ${argsStr}\`
-        - \`${script} ${argsStr}\`
-    `)
-    throw new Error(`Could not resolve binary for \`${cmd}\``)
-  }
-}

package/packages/config-stylelint/node_modules/lint-staged/src/findBin.js

@@ -1,54 +0,0 @@
-'use strict'
-
-const parse = require('string-argv')
-const npmWhich = require('npm-which')(process.cwd())
-const checkPkgScripts = require('./checkPkgScripts')
-
-const debug = require('debug')('lint-staged:find-bin')
-
-// Find and load the package.json at the root of the project.
-let pkg
-try {
-  // eslint-disable-next-line import/no-dynamic-require, global-require
-  pkg = require(`${process.cwd()}/package.json`)
-  debug('Loaded package.json using `process.cwd()`')
-} catch (ignore) {
-  debug('Could not load package.json using `process.cwd()`')
-  pkg = {}
-}
-
-const cache = new Map()
-
-module.exports = function findBin(cmd) {
-  debug('Resolving binary for command `%s`', cmd)
-
-  /*
-   *  Try to locate the binary in node_modules/.bin and if this fails, in
-   *  $PATH.
-   *
-   *  This allows to use linters installed for the project:
-   *
-   *  "lint-staged": {
-   *    "*.js": "eslint"
-   *  }
-   */
-  const [binName, ...args] = parse(cmd)
-
-  if (cache.has(binName)) {
-    debug('Resolving binary for `%s` from cache', binName)
-    return { bin: cache.get(binName), args }
-  }
-
-  try {
-    /* npm-which tries to resolve the bin in local node_modules/.bin */
-    /* and if this fails it look in $PATH */
-    const bin = npmWhich.sync(binName)
-    debug('Binary for `%s` resolved to `%s`', cmd, bin)
-    cache.set(binName, bin)
-    return { bin, args }
-  } catch (err) {
-    // throw helpful error if matching script is present in package.json
-    checkPkgScripts(pkg, cmd, binName, args)
-    throw new Error(`${binName} could not be found. Try \`npm install ${binName}\`.`)
-  }
-}

package/packages/config-stylelint/node_modules/lint-staged/src/generateTasks.js

@@ -1,45 +0,0 @@
-'use strict'
-
-const path = require('path')
-const micromatch = require('micromatch')
-const pathIsInside = require('path-is-inside')
-const { getConfig } = require('./getConfig')
-const resolveGitDir = require('./resolveGitDir')
-
-const debug = require('debug')('lint-staged:gen-tasks')
-
-module.exports = function generateTasks(config, stagedRelFiles) {
-  debug('Generating linter tasks')
-
-  const normalizedConfig = getConfig(config) // Ensure we have a normalized config
-  const { linters, globOptions } = normalizedConfig
-  const ignorePatterns = normalizedConfig.ignore.map(pattern => `!${pattern}`)
-
-  const gitDir = resolveGitDir()
-  const cwd = process.cwd()
-  const stagedFiles = stagedRelFiles.map(file => path.resolve(gitDir, file))
-
-  return Object.keys(linters).map(pattern => {
-    const isParentDirPattern = pattern.startsWith('../')
-    const patterns = [pattern].concat(ignorePatterns)
-    const commands = linters[pattern]
-
-    const fileList = micromatch(
-      stagedFiles
-        // Only worry about children of the CWD unless the pattern explicitly
-        // specifies that it concerns a parent directory.
-        .filter(file => isParentDirPattern || pathIsInside(file, cwd))
-        // Make the paths relative to CWD for filtering
-        .map(file => path.relative(cwd, file)),
-      patterns,
-      globOptions
-    )
-      // Return absolute path after the filter is run
-      .map(file => path.resolve(cwd, file))
-
-    const task = { pattern, commands, fileList }
-    debug('Generated task: \n%O', task)
-
-    return task
-  })
-}

package/packages/config-stylelint/node_modules/lint-staged/src/getConfig.js

@@ -1,152 +0,0 @@
-/* eslint no-prototype-builtins: 0 */
-
-'use strict'
-
-const chalk = require('chalk')
-const format = require('stringify-object')
-const intersection = require('lodash/intersection')
-const defaultsDeep = require('lodash/defaultsDeep')
-const isObject = require('lodash/isObject')
-const { validate, logValidationWarning } = require('jest-validate')
-const { unknownOptionWarning } = require('jest-validate/build/warnings')
-const isGlob = require('is-glob')
-
-const debug = require('debug')('lint-staged:cfg')
-
-/**
- * Default config object
- *
- * @type {{concurrent: boolean, chunkSize: number, globOptions: {matchBase: boolean, dot: boolean}, linters: {}, subTaskConcurrency: number, renderer: string}}
- */
-const defaultConfig = {
-  concurrent: true,
-  chunkSize: Number.MAX_SAFE_INTEGER,
-  globOptions: {
-    matchBase: true,
-    dot: true
-  },
-  linters: {},
-  ignore: [],
-  subTaskConcurrency: 1,
-  renderer: 'update'
-}
-
-/**
- * Check if the config is "simple" i.e. doesn't contains any of full config keys
- *
- * @param config
- * @returns {boolean}
- */
-function isSimple(config) {
-  return (
-    isObject(config) &&
-    !config.hasOwnProperty('linters') &&
-    intersection(Object.keys(defaultConfig), Object.keys(config)).length === 0
-  )
-}
-
-/**
- * Custom jest-validate reporter for unknown options
- * @param config
- * @param example
- * @param option
- * @param options
- * @returns {void}
- */
-function unknownValidationReporter(config, example, option, options) {
-  /**
-   * If the unkonwn property is a glob this is probably
-   * a typical mistake of mixing simple and advanced configs
-   */
-  if (isGlob(option)) {
-    // prettier-ignore
-    const message = `  Unknown option ${chalk.bold(`"${option}"`)} with value ${chalk.bold(
-    format(config[option], { inlineCharacterLimit: Number.POSITIVE_INFINITY })
-  )} was found in the config root.
-
-  You are probably trying to mix simple and advanced config formats. Adding
-
-  ${chalk.bold(`"linters": {
-    "${option}": ${JSON.stringify(config[option])}
-  }`)}
-
-  will fix it and remove this message.`
-
-    const { comment } = options
-    const name = options.title.warning
-    return logValidationWarning(name, message, comment)
-  }
-  // If it is not glob pattern, use default jest-validate reporter
-  return unknownOptionWarning(config, example, option, options)
-}
-
-/**
- * For a given configuration object that we retrive from .lintstagedrc or package.json
- * construct a full configuration with all options set.
- *
- * This is a bit tricky since we support 2 different syntxes: simple and full
- * For simple config, only the `linters` configuration is provided.
- *
- * @param {Object} sourceConfig
- * @returns {{
- *  concurrent: boolean, chunkSize: number, globOptions: {matchBase: boolean, dot: boolean}, linters: {}, subTaskConcurrency: number, renderer: string
- * }}
- */
-function getConfig(sourceConfig, debugMode) {
-  debug('Normalizing config')
-  const config = defaultsDeep(
-    {}, // Do not mutate sourceConfig!!!
-    isSimple(sourceConfig) ? { linters: sourceConfig } : sourceConfig,
-    defaultConfig
-  )
-
-  // Check if renderer is set in sourceConfig and if not, set accordingly to verbose
-  if (isObject(sourceConfig) && !sourceConfig.hasOwnProperty('renderer')) {
-    config.renderer = debugMode ? 'verbose' : 'update'
-  }
-
-  return config
-}
-
-const optRmMsg = (opt, helpMsg) => `  Option ${chalk.bold(opt)} was removed.
-
-  ${helpMsg}
-
-  Please remove ${chalk.bold(opt)} from your configuration.`
-
-/**
- * Runs config validation. Throws error if the config is not valid.
- * @param config {Object}
- * @returns config {Object}
- */
-function validateConfig(config) {
-  debug('Validating config')
-  const exampleConfig = Object.assign({}, defaultConfig, {
-    linters: {
-      '*.js': ['eslint --fix', 'git add'],
-      '*.css': 'stylelint'
-    }
-  })
-
-  const deprecatedConfig = {
-    gitDir: () => optRmMsg('gitDir', "lint-staged now automatically resolves '.git' directory."),
-    verbose: () =>
-      optRmMsg('verbose', `Use the command line flag ${chalk.bold('--debug')} instead.`)
-  }
-
-  validate(config, {
-    exampleConfig,
-    deprecatedConfig,
-    unknown: unknownValidationReporter,
-    recursive: false,
-    comment:
-      'Please refer to https://github.com/okonet/lint-staged#configuration for more information...'
-  })
-
-  return config
-}
-
-module.exports = {
-  getConfig,
-  validateConfig
-}

package/packages/config-stylelint/node_modules/lint-staged/src/index.js

@@ -1,99 +0,0 @@
-'use strict'
-
-const dedent = require('dedent')
-const cosmiconfig = require('cosmiconfig')
-const stringifyObject = require('stringify-object')
-const { getConfig, validateConfig } = require('./getConfig')
-const printErrors = require('./printErrors')
-const runAll = require('./runAll')
-
-const debug = require('debug')('lint-staged')
-
-// Force colors for packages that depend on https://www.npmjs.com/package/supports-color
-// but do this only in TTY mode
-if (process.stdout.isTTY) {
-  // istanbul ignore next
-  process.env.FORCE_COLOR = '1'
-}
-
-const errConfigNotFound = new Error('Config could not be found')
-
-function resolveConfig(configPath) {
-  try {
-    return require.resolve(configPath)
-  } catch (ignore) {
-    return configPath
-  }
-}
-
-function loadConfig(configPath) {
-  const explorer = cosmiconfig('lint-staged', {
-    searchPlaces: [
-      'package.json',
-      '.lintstagedrc',
-      '.lintstagedrc.json',
-      '.lintstagedrc.yaml',
-      '.lintstagedrc.yml',
-      '.lintstagedrc.js',
-      'lint-staged.config.js'
-    ]
-  })
-
-  return configPath ? explorer.load(resolveConfig(configPath)) : explorer.search()
-}
-
-/**
- * Root lint-staged function that is called from .bin
- */
-module.exports = function lintStaged(logger = console, configPath, debugMode) {
-  debug('Loading config using `cosmiconfig`')
-
-  return loadConfig(configPath)
-    .then(result => {
-      if (result == null) throw errConfigNotFound
-
-      debug('Successfully loaded config from `%s`:\n%O', result.filepath, result.config)
-      // result.config is the parsed configuration object
-      // result.filepath is the path to the config file that was found
-      const config = validateConfig(getConfig(result.config, debugMode))
-      if (debugMode) {
-        // Log using logger to be able to test through `consolemock`.
-        logger.log('Running lint-staged with the following config:')
-        logger.log(stringifyObject(config, { indent: '  ' }))
-      } else {
-        // We might not be in debug mode but `DEBUG=lint-staged*` could have
-        // been set.
-        debug('Normalized config:\n%O', config)
-      }
-
-      runAll(config)
-        .then(() => {
-          debug('linters were executed successfully!')
-          // No errors, exiting with 0
-        })
-        .catch(error => {
-          // Errors detected, printing and exiting with non-zero
-          process.exitCode = 1
-          printErrors(error)
-        })
-    })
-    .catch(err => {
-      process.exitCode = 1
-      if (err === errConfigNotFound) {
-        logger.error(`${err.message}.`)
-      } else {
-        // It was probably a parsing error
-        logger.error(dedent`
-          Could not parse lint-staged config.
-
-          ${err}
-        `)
-      }
-      logger.error() // empty line
-      // Print helpful message for all errors
-      logger.error(dedent`
-        Please make sure you have created it correctly.
-        See https://github.com/okonet/lint-staged#configuration.
-      `)
-    })
-}

package/packages/config-stylelint/node_modules/lint-staged/src/makeCmdTasks.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const resolveTaskFn = require('./resolveTaskFn')
-const resolveGitDir = require('./resolveGitDir')
-
-const debug = require('debug')('lint-staged:make-cmd-tasks')
-
-/**
- * Creates and returns an array of listr tasks which map to the given commands.
- *
- * @param {Array<string>|string} commands
- * @param {Array<string>} pathsToLint
- * @param {Object} [options]
- * @param {number} options.chunkSize
- * @param {number} options.subTaskConcurrency
- */
-module.exports = function makeCmdTasks(
-  commands,
-  pathsToLint,
-  { chunkSize = Number.MAX_SAFE_INTEGER, subTaskConcurrency = 1 } = {}
-) {
-  debug('Creating listr tasks for commands %o', commands)
-
-  const gitDir = resolveGitDir()
-  const lintersArray = Array.isArray(commands) ? commands : [commands]
-
-  return lintersArray.map(linter => ({
-    title: linter,
-    task: resolveTaskFn({
-      linter,
-      gitDir,
-      pathsToLint,
-      chunkSize,
-      subTaskConcurrency
-    })
-  }))
-}

package/packages/config-stylelint/node_modules/lint-staged/src/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) {
-  if (Array.isArray(errorInstance.errors)) {
-    errorInstance.errors.forEach(lintError => {
-      console.error(errMsg(lintError))
-    })
-  } else {
-    console.error(errMsg(errorInstance))
-  }
-}

package/packages/config-stylelint/node_modules/lint-staged/src/resolveGitDir.js

@@ -1,7 +0,0 @@
-'use strict'
-
-const findParentDir = require('find-parent-dir')
-
-module.exports = function resolveGitDir() {
-  return findParentDir.sync(process.cwd(), '.git')
-}

package/packages/config-stylelint/node_modules/lint-staged/src/resolveTaskFn.js

@@ -1,118 +0,0 @@
-'use strict'
-
-const chunk = require('lodash/chunk')
-const dedent = require('dedent')
-const isWindows = require('is-windows')
-const execa = require('execa')
-const symbols = require('log-symbols')
-const pMap = require('p-map')
-const calcChunkSize = require('./calcChunkSize')
-const findBin = require('./findBin')
-
-const debug = require('debug')('lint-staged:task')
-
-/**
- * Execute the given linter binary with arguments and file paths using execa and
- * return the promise.
- *
- * @param {string} bin
- * @param {Array<string>} args
- * @param {Object} execaOptions
- * @param {Array<string>} pathsToLint
- * @return {Promise}
- */
-function execLinter(bin, args, execaOptions, pathsToLint) {
-  const binArgs = args.concat(pathsToLint)
-
-  debug('bin:', bin)
-  debug('args: %O', binArgs)
-  debug('opts: %o', execaOptions)
-
-  return execa(bin, binArgs, Object.assign({}, execaOptions))
-}
-
-const successMsg = linter => `${symbols.success} ${linter} passed!`
-
-/**
- * Create and returns an error instance with given stdout and stderr. 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.
- *
- * @param {string} linter
- * @param {string} errStdout
- * @param {string} errStderr
- * @returns {Error}
- */
-function makeErr(linter, errStdout, errStderr) {
-  const err = new Error()
-  err.privateMsg = dedent`
-    ${symbols.error} "${linter}" found some errors. Please fix them and try committing again.
-    ${errStdout}
-    ${errStderr}
-  `
-  return err
-}
-
-/**
- * Returns the task function for the linter. It handles chunking for file paths
- * if the OS is Windows.
- *
- * @param {Object} options
- * @param {string} options.linter
- * @param {string} options.gitDir
- * @param {Array<string>} options.pathsToLint
- * @param {number} options.chunkSize
- * @param {number} options.subTaskConcurrency
- * @returns {function(): Promise<string>}
- */
-module.exports = function resolveTaskFn(options) {
-  const { linter, gitDir, pathsToLint } = options
-  const { bin, args } = findBin(linter)
-
-  const execaOptions = { reject: false }
-  // Only use gitDir as CWD if we are using the git binary
-  // e.g `npm` should run tasks in the actual CWD
-  if (/git(\.exe)?$/i.test(bin) && gitDir !== process.cwd()) {
-    execaOptions.cwd = gitDir
-  }
-
-  if (!isWindows()) {
-    debug('%s  OS: %s; File path chunking unnecessary', symbols.success, process.platform)
-    return () =>
-      execLinter(bin, args, execaOptions, pathsToLint).then(result => {
-        if (!result.failed) return successMsg(linter)
-
-        throw makeErr(linter, result.stdout, result.stderr)
-      })
-  }
-
-  const { chunkSize, subTaskConcurrency: concurrency } = options
-
-  const filePathChunks = chunk(pathsToLint, calcChunkSize(pathsToLint, chunkSize))
-  const mapper = execLinter.bind(null, bin, args, execaOptions)
-
-  debug(
-    'OS: %s; Creating linter task with %d chunked file paths',
-    process.platform,
-    filePathChunks.length
-  )
-  return () =>
-    pMap(filePathChunks, mapper, { concurrency })
-      .catch(err => {
-        /* This will probably never be called. But just in case.. */
-        throw new Error(dedent`
-        ${symbols.error} ${linter} got an unexpected error.
-        ${err.message}
-      `)
-      })
-      .then(results => {
-        const errors = results.filter(res => res.failed)
-        if (errors.length === 0) return successMsg(linter)
-
-        const errStdout = errors.map(err => err.stdout).join('')
-        const errStderr = errors.map(err => err.stderr).join('')
-
-        throw makeErr(linter, errStdout, errStderr)
-      })
-}

package/packages/config-stylelint/node_modules/lint-staged/src/runAll.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const sgf = require('staged-git-files')
-const Listr = require('listr')
-const has = require('lodash/has')
-const pify = require('pify')
-const makeCmdTasks = require('./makeCmdTasks')
-const generateTasks = require('./generateTasks')
-const resolveGitDir = require('./resolveGitDir')
-
-const debug = require('debug')('lint-staged:run')
-
-/**
- * Executes all tasks and either resolves or rejects the promise
- * @param config {Object}
- * @returns {Promise}
- */
-module.exports = function runAll(config) {
-  debug('Running all linter scripts')
-  // Config validation
-  if (!config || !has(config, 'concurrent') || !has(config, 'renderer')) {
-    throw new Error('Invalid config provided to runAll! Use getConfig instead.')
-  }
-
-  const { concurrent, renderer, chunkSize, subTaskConcurrency } = config
-  const gitDir = resolveGitDir()
-  debug('Resolved git directory to be `%s`', gitDir)
-
-  sgf.cwd = gitDir
-  return pify(sgf)('ACM').then(files => {
-    /* files is an Object{ filename: String, status: String } */
-    const filenames = files.map(file => file.filename)
-    debug('Loaded list of staged files in git:\n%O', filenames)
-
-    const tasks = generateTasks(config, filenames).map(task => ({
-      title: `Running tasks for ${task.pattern}`,
-      task: () =>
-        new Listr(
-          makeCmdTasks(task.commands, task.fileList, {
-            chunkSize,
-            subTaskConcurrency
-          }),
-          {
-            // In sub-tasks we don't want to run concurrently
-            // and we want to abort on errors
-            dateFormat: false,
-            concurrent: false,
-            exitOnError: true
-          }
-        ),
-      skip: () => {
-        if (task.fileList.length === 0) {
-          return `No staged files match ${task.pattern}`
-        }
-        return false
-      }
-    }))
-
-    if (tasks.length) {
-      return new Listr(tasks, {
-        dateFormat: false,
-        concurrent,
-        renderer,
-        exitOnError: !concurrent // Wait for all errors when running concurrently
-      }).run()
-    }
-    return 'No tasks to run.'
-  })
-}