Function analyzer

module.js:93–156

(bundle, opts = {})

}

const analyzer = (bundle, opts = {}) => {
  const { limit, filter, transformModuleId, filterSummary } = opts
  const root = opts.root || (process && process.cwd ? process.cwd() : null)
  const idMod = typeof transformModuleId === 'function' && transformModuleId
  const filterType = Array.isArray(filter) ? 'array' : typeof filter
  const applyFilter = filterByType[filterType]
  const bundleModules = bundle.modules || (bundle.cache || {}).modules || []
  const deps = {}

  let tmpBdlSize = 0
  let bundleSize = 0
  let bundleOrigSize = 0

  let modules = bundleModules.map((m, i) => {
    const id = idMod ? idMod(m.id.replace(root, '')) : m.id.replace(root, '')
    const {
      originalLength,
      renderedLength,
      renderedExports,
      removedExports,
      originalCode,
      code
    } = m

    const size = sizeOrCodeSize(renderedLength, code)
    const origSize = sizeOrCodeSize(originalLength, originalCode)

    tmpBdlSize += size

    m.dependencies.forEach((d) => {
      d = idMod ? idMod(d.replace(root, '')) : d.replace(root, '')
      deps[d] = deps[d] || []
      deps[d].push(id)
    })

    return { id, size, origSize, renderedExports, removedExports }
  }).filter((m) => m).sort((a, b) => b.size - a.size)

  modules = modules.map((m, i) => {
    m.dependents = deps[m.id] || []
    m.percent = Math.min(((m.size / tmpBdlSize) * 100).toFixed(2), 100)
    m.reduction = shakenPct(m.size, m.origSize)

    const filtered = applyFilter && !applyFilter(filter, m)
    const limited = !Number.isNaN(+limit) && i >= limit
    if ((limited || filtered) && filterSummary) return null

    bundleSize += m.size
    bundleOrigSize += m.origSize

    return (limited || filtered) ? null : m
  }).filter((m) => m)

  if (filterSummary) {
    modules.forEach((m) => {
      m.percent = Math.min(((m.size / bundleSize) * 100).toFixed(2), 100)
    })
  }