line_push/node_modules/@nuxt/friendly-errors-webpack-plugin/src/friendly-errors-plugin.js

'use strict'

const transformErrors = require('./core/transformErrors')
const formatErrors = require('./core/formatErrors')
const reporters = require('./reporters')
const utils = require('./utils')
const { titles } = require('./utils/log')

const concat = utils.concat
const uniqueBy = utils.uniqueBy

const defaultTransformers = [
  require('./transformers/babelSyntax'),
  require('./transformers/moduleNotFound'),
  require('./transformers/esLintError')
]

const defaultFormatters = [
  require('./formatters/moduleNotFound'),
  require('./formatters/eslintError'),
  require('./formatters/defaultError')
]

const logLevels = {
  'INFO': 0,
  'WARNING': 1,
  'ERROR': 2,
  'SILENT': 3
}

class FriendlyErrorsWebpackPlugin {
  constructor (options) {
    options = options || {}
    this.compilationSuccessInfo = options.compilationSuccessInfo || {}
    this.onErrors = options.onErrors
    this.shouldClearConsole = options.clearConsole == null ? true : Boolean(options.clearConsole)
    this.logLevel = logLevels[(options.logLevel || 'info').toUpperCase()]
    this.formatters = concat(defaultFormatters, options.additionalFormatters)
    this.transformers = concat(defaultTransformers, options.additionalTransformers)
    this.previousEndTimes = {}

    let reporter = options.reporter || 'base'
    if (typeof reporter === 'string') {
      reporter = new (require(reporters[reporter] || reporter))()
    }
    this.reporter = reporter
  }

  apply (compiler) {
    const doneFn = stats => {
      this.clearConsole()

      const hasErrors = stats.hasErrors()
      const hasWarnings = stats.hasWarnings()

      let cleared = false

      if (!hasErrors && !hasWarnings && this.logLevel < 1) {
        cleared = this.clearConsole()
        this.displaySuccess(stats)
        return
      }

      if (hasWarnings && this.logLevel < 2) {
        cleared = this.clearConsole()
        this.displayErrors(extractErrorsFromStats(stats, 'warnings'), 'warn')
      }

      if (hasErrors && this.logLevel < 3) {
        cleared || this.clearConsole()
        this.displayErrors(extractErrorsFromStats(stats, 'errors'), 'error')
      }
    }

    const invalidFn = () => {
      this.clearConsole()
      this.reporter.info('WAIT', 'Compiling...')
    }

    if (compiler.hooks) {
      const plugin = { name: 'FriendlyErrorsWebpackPlugin' }

      compiler.hooks.done.tap(plugin, doneFn)
      compiler.hooks.invalid.tap(plugin, invalidFn)
    } else {
      compiler.plugin('done', doneFn)
      compiler.plugin('invalid', invalidFn)
    }
  }

  clearConsole () {
    if (this.shouldClearConsole) {
      this.reporter.clearConsole()
    }
    return true
  }

  displaySuccess (stats) {
    const time = isMultiStats(stats) ? this.getMultiStatsCompileTime(stats) : this.getStatsCompileTime(stats)
    this.reporter.success('DONE', 'Compiled successfully in ' + time + 'ms')

    if (this.compilationSuccessInfo.messages) {
      this.compilationSuccessInfo.messages.forEach(message => this.reporter.info(message))
    }
    if (this.compilationSuccessInfo.notes) {
      this.reporter.log()
      this.compilationSuccessInfo.notes.forEach(note => this.reporter.note(note))
    }
  }

  displayErrors (errors, severity) {
    const processedErrors = transformErrors(errors, this.transformers)

    const topErrors = getMaxSeverityErrors(processedErrors)
    const nbErrors = topErrors.length

    const subtitle = severity === 'error'
      ? `Failed to compile with ${nbErrors} ${titles[severity]}s`
      : `Compiled with ${nbErrors} ${titles[severity]}s`
    this.reporter[severity](severity.toUpperCase(), subtitle)

    if (this.onErrors) {
      this.onErrors(severity, topErrors)
    }

    formatErrors(topErrors, this.formatters, severity)
      .forEach(chunk => {
        this.reporter[severity].apply(this.reporter, [].concat(chunk))
      })
  }

  getStatsCompileTime (stats, statsIndex) {
    // When we have multi compilations but only one of them is rebuilt, we need to skip the
    // unchanged compilers to report the true rebuild time.
    if (statsIndex !== undefined) {
      if (this.previousEndTimes[statsIndex] === stats.endTime) {
        return 0
      }

      this.previousEndTimes[statsIndex] = stats.endTime
    }

    return stats.endTime - stats.startTime
  }

  getMultiStatsCompileTime (stats) {
    // Webpack multi compilations run in parallel so using the longest duration.
    // https://webpack.github.io/docs/configuration.html#multiple-configurations
    return stats.stats
      .reduce((time, stats, index) => Math.max(time, this.getStatsCompileTime(stats, index)), 0)
  }
}

function extractErrorsFromStats (stats, type) {
  let errors = []
  if (isMultiStats(stats)) {
    errors = stats.stats
      .reduce((errors, stats) => errors.concat(extractErrorsFromStats(stats, type)), [])
  } else {
    if (Array.isArray(stats.compilation.children)) {
      for (const child of stats.compilation.children) {
        const childStats = child.getStats()
        errors.push.apply(errors, extractErrorsFromStats(childStats, type))
      }
    }
    errors.push.apply(errors, stats.compilation[type])
  }
  // Dedupe to avoid showing the same error many times when multiple
  // compilers depend on the same module.
  return uniqueBy(errors, error => error.message)
}

function isMultiStats (stats) {
  return stats.stats
}

function getMaxSeverityErrors (errors) {
  const maxSeverity = getMaxInt(errors, 'severity')
  return errors.filter(e => e.severity === maxSeverity)
}

function getMaxInt (collection, propertyName) {
  return collection.reduce((res, curr) => {
    return curr[propertyName] > res ? curr[propertyName] : res
  }, 0)
}

module.exports = FriendlyErrorsWebpackPlugin