Function analyzer

index.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);
    });
  }