@alexlit/lint-kit 186.0.1 → 186.1.1

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

@@ -0,0 +1,42 @@
+'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

@@ -0,0 +1,46 @@
+'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

@@ -0,0 +1,54 @@
+'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

@@ -0,0 +1,45 @@
+'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

@@ -0,0 +1,152 @@
+/* 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

@@ -0,0 +1,99 @@
+'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

@@ -0,0 +1,37 @@
+'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

@@ -0,0 +1,15 @@
+'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

@@ -0,0 +1,7 @@
+'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

@@ -0,0 +1,118 @@
+'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

@@ -0,0 +1,69 @@
+'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.'
+  })
+}