webpack-bundle-analyzer/lib/parseUtils.js

'use strict';

var fs = require('fs');
var _ = require('lodash');
var acorn = require('acorn');
var walk = require('acorn/dist/walk');

module.exports = {
  getModuleSizesFromBundle: getModuleSizesFromBundle
};

function getModuleSizesFromBundle(bundlePath) {
  var ast = acorn.parse(fs.readFileSync(bundlePath, 'utf8'), {
    sourceType: 'script'
  });

  var walkState = {
    sizes: null
  };

  walk.recursive(ast, walkState, {
    CallExpression: function CallExpression(node, state, c) {
      if (state.sizes) return;

      var args = node.arguments;

      // Additional bundle without webpack loader
      // Modules are stored in second argument:
      // webpackJsonp([<chunks>], <modules>)
      if (_.get(node, 'callee.name') === 'webpackJsonp') {
        state.sizes = getModulesSizesFromFunctionArgument(args[1]);
        return;
      }

      // Main bundle with webpack loader
      // Modules are stored in first argument:
      // (function (...) {...})(<modules>)
      if (node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1) {
        var arg = args[0];


        if (arg.type === 'CallExpression') {
          // DedupePlugin and maybe some others wrap modules in additional self-invoking function expression.
          // Walking into it.
          return c(arg, state);
        } else if (isArgumentContainsModulesList(arg)) {
          state.sizes = getModulesSizesFromFunctionArgument(arg);
        }
      }
    }
  });

  return walkState.sizes;
}

function isArgumentContainsModulesList(arg) {
  if (arg.type === 'ObjectExpression') {
    return _(arg.properties).map('value').every(isModuleWrapper);
  }

  if (arg.type === 'ArrayExpression') {
    // Modules are contained in array.
    // Array indexes are module ids
    return _.every(arg.elements, function (elem) {
      return (
        // Some of array items may be skipped because there is no module with such id
        !elem || isModuleWrapper(elem)
      );
    });
  }

  return false;
}

function isModuleWrapper(node) {
  return (
    // It's an anonymous function expression that wraps module
    node.type === 'FunctionExpression' && !node.id ||
    // If `DedupePlugin` is used it can be an ID of duplicated module
    node.type === 'Literal' && (typeof node.value === 'number' || typeof node.value === 'string')
  );
}

function getModulesSizesFromFunctionArgument(arg) {
  if (arg.type === 'ObjectExpression') {
    var modulesNodes = arg.properties;

    return _.transform(modulesNodes, function (result, moduleNode) {
      var moduleId = moduleNode.key.name || moduleNode.key.value;

      result[moduleId] = getModuleSize(moduleNode.value);
    }, {});
  }

  if (arg.type === 'ArrayExpression') {
    var _modulesNodes = arg.elements;

    return _.transform(_modulesNodes, function (result, moduleNode, i) {
      if (!moduleNode) return;

      result[i] = getModuleSize(moduleNode);
    }, {});
  }

  return {};
}

function getModuleSize(node) {
  if (node.type === 'FunctionExpression') {
    return node.body.end - node.body.start;
  }

  if (node.type === 'Literal') {
    return node.end - node.start;
  }

  // Fallback for unknown node types
  return 0;
}