webpack-bundle-analyzer 2.13.1 → 3.0.2

package/lib/bin/analyzer.js

@@ -1,60 +1,55 @@
 #! /usr/bin/env node
-'use strict';
+"use strict";
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+const {
+  resolve,
+  dirname
+} = require('path');
 
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+const _ = require('lodash');
 
-var _require = require('path'),
-    resolve = _require.resolve,
-    dirname = _require.dirname;
+const commander = require('commander');
 
-var _ = require('lodash');
-var commander = require('commander');
+const {
+  magenta
+} = require('chalk');
 
-var _require2 = require('chalk'),
-    magenta = _require2.magenta;
+const analyzer = require('../analyzer');
 
-var analyzer = require('../analyzer');
-var viewer = require('../viewer');
-var Logger = require('../Logger');
+const viewer = require('../viewer');
 
-var SIZES = new Set(['stat', 'parsed', 'gzip']);
+const Logger = require('../Logger');
 
-var program = commander.version(require('../../package.json').version).usage(`<bundleStatsFile> [bundleDir] [options]
+const SIZES = new Set(['stat', 'parsed', 'gzip']);
+const program = commander.version(require('../../package.json').version).usage(`<bundleStatsFile> [bundleDir] [options]
 
   Arguments:
   
     bundleStatsFile  Path to Webpack Stats JSON file.
     bundleDir        Directory containing all generated bundles.
                      You should provided it if you want analyzer to show you the real parsed module sizes.
-                     By default a directory of stats file is used.`).option('-m, --mode <mode>', 'Analyzer mode. Should be `server` or `static`.' + br('In `server` mode analyzer will start HTTP server to show bundle report.') + br('In `static` mode single HTML file with bundle report will be generated.'), 'server').option('-h, --host <host>', 'Host that will be used in `server` mode to start HTTP server.', '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.', Number, 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.', 'report.html').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[].concat(_toConsumableArray(SIZES)).join(', ')}`), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").option('-e, --exclude <regexp>', 'Assets that should be excluded from the report.' + br('Can be specified multiple times.'), array()).option('-l, --log-level <level>', 'Log level.' + br(`Possible values: ${[].concat(_toConsumableArray(Logger.levels)).join(', ')}`), Logger.defaultLevel).parse(process.argv);
-
-var mode = program.mode,
-    host = program.host,
-    port = program.port,
-    reportFilename = program.report,
-    defaultSizes = program.defaultSizes,
-    logLevel = program.logLevel,
-    openBrowser = program.open,
-    excludeAssets = program.exclude,
-    _program$args = _slicedToArray(program.args, 2),
-    bundleStatsFile = _program$args[0],
-    bundleDir = _program$args[1];
-
-var logger = new Logger(logLevel);
-
+                     By default a directory of stats file is used.`).option('-m, --mode <mode>', 'Analyzer mode. Should be `server` or `static`.' + br('In `server` mode analyzer will start HTTP server to show bundle report.') + br('In `static` mode single HTML file with bundle report will be generated.'), 'server').option('-h, --host <host>', 'Host that will be used in `server` mode to start HTTP server.', '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.', Number, 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.', 'report.html').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[...SIZES].join(', ')}`), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").option('-e, --exclude <regexp>', 'Assets that should be excluded from the report.' + br('Can be specified multiple times.'), array()).option('-l, --log-level <level>', 'Log level.' + br(`Possible values: ${[...Logger.levels].join(', ')}`), Logger.defaultLevel).parse(process.argv);
+let {
+  mode,
+  host,
+  port,
+  report: reportFilename,
+  defaultSizes,
+  logLevel,
+  open: openBrowser,
+  exclude: excludeAssets,
+  args: [bundleStatsFile, bundleDir]
+} = program;
+const logger = new Logger(logLevel);
 if (!bundleStatsFile) showHelp('Provide path to Webpack Stats file as first argument');
 if (mode !== 'server' && mode !== 'static') showHelp('Invalid mode. Should be either `server` or `static`.');
 if (mode === 'server' && !host) showHelp('Invalid host name');
 if (mode === 'server' && isNaN(port)) showHelp('Invalid port number');
-if (!SIZES.has(defaultSizes)) showHelp(`Invalid default sizes option. Possible values are: ${[].concat(_toConsumableArray(SIZES)).join(', ')}`);
-
+if (!SIZES.has(defaultSizes)) showHelp(`Invalid default sizes option. Possible values are: ${[...SIZES].join(', ')}`);
 bundleStatsFile = resolve(bundleStatsFile);
-
 if (!bundleDir) bundleDir = dirname(bundleStatsFile);
+let bundleStats;
 
-var bundleStats = void 0;
 try {
   bundleStats = analyzer.readStatsFromFile(bundleStatsFile);
 } catch (err) {
@@ -95,8 +90,8 @@ function br(str) {
 }
 
 function array() {
-  var arr = [];
-  return function (val) {
+  const arr = [];
+  return val => {
     arr.push(val);
     return arr;
   };

package/lib/index.js

@@ -1,7 +1,8 @@
-'use strict';
+"use strict";
 
-var _require = require('./viewer'),
-    start = _require.start;
+const {
+  start
+} = require('./viewer');
 
 module.exports = {
   start,

package/lib/parseUtils.js

@@ -1,72 +1,67 @@
-'use strict';
+"use strict";
 
-var fs = require('fs');
-var _ = require('lodash');
-var acorn = require('acorn');
-var walk = require('acorn/dist/walk');
+const fs = require('fs');
+
+const _ = require('lodash');
+
+const acorn = require('acorn');
+
+const walk = require('acorn/dist/walk');
 
 module.exports = {
   parseBundle
 };
 
 function parseBundle(bundlePath) {
-  var content = fs.readFileSync(bundlePath, 'utf8');
-  var ast = acorn.parse(content, {
+  const content = fs.readFileSync(bundlePath, 'utf8');
+  const ast = acorn.parse(content, {
     sourceType: 'script',
     // I believe in a bright future of ECMAScript!
     // Actually, it's set to `2050` to support the latest ECMAScript version that currently exists.
     // Seems like `acorn` supports such weird option value.
     ecmaVersion: 2050
   });
-
-  var walkState = {
+  const walkState = {
     locations: null
   };
-
   walk.recursive(ast, walkState, {
     CallExpression(node, state, c) {
       if (state.locations) return;
-
-      var args = node.arguments;
-
-      // Main chunk with webpack loader.
+      const args = node.arguments; // Main chunk with webpack loader.
       // Modules are stored in first argument:
       // (function (...) {...})(<modules>)
+
       if (node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
         state.locations = getModulesLocations(args[0]);
         return;
-      }
-
-      // Async Webpack < v4 chunk without webpack loader.
+      } // Async Webpack < v4 chunk without webpack loader.
       // webpackJsonp([<chunks>], <modules>, ...)
       // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+
+
       if (node.callee.type === 'Identifier' && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
         state.locations = getModulesLocations(args[1]);
         return;
-      }
-
-      // Async Webpack v4 chunk without webpack loader.
+      } // Async Webpack v4 chunk without webpack loader.
       // (window.webpackJsonp=window.webpackJsonp||[]).push([[<chunks>], <modules>, ...]);
       // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+
+
       if (isAsyncChunkPushExpression(node)) {
         state.locations = getModulesLocations(args[0].elements[1]);
         return;
-      }
-
-      // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
+      } // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
       // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
-      _.each(args, function (arg) {
-        return c(arg, state);
-      });
+
+
+      _.each(args, arg => c(arg, state));
     }
-  });
 
-  var modules = void 0;
+  });
+  let modules;
 
   if (walkState.locations) {
-    modules = _.mapValues(walkState.locations, function (loc) {
-      return content.slice(loc.start, loc.end);
-    });
+    modules = _.mapValues(walkState.locations, loc => content.slice(loc.start, loc.end));
   } else {
     modules = {};
   }
@@ -78,16 +73,13 @@ function parseBundle(bundlePath) {
 }
 
 function isModulesList(node) {
-  return isSimpleModulesList(node) ||
-  // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+  return isSimpleModulesList(node) || // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
   isOptimizedModulesArray(node);
 }
 
 function isSimpleModulesList(node) {
-  return (
-    // Modules are contained in hash. Keys are module ids.
-    isModulesHash(node) ||
-    // Modules are contained in array. Indexes are module ids.
+  return (// Modules are contained in hash. Keys are module ids.
+    isModulesHash(node) || // Modules are contained in array. Indexes are module ids.
     isModulesArray(node)
   );
 }
@@ -97,34 +89,24 @@ function isModulesHash(node) {
 }
 
 function isModulesArray(node) {
-  return node.type === 'ArrayExpression' && _.every(node.elements, function (elem) {
-    return (
-      // Some of array items may be skipped because there is no module with such id
-      !elem || isModuleWrapper(elem)
-    );
-  });
+  return node.type === 'ArrayExpression' && _.every(node.elements, elem => // Some of array items may be skipped because there is no module with such id
+  !elem || isModuleWrapper(elem));
 }
 
 function isOptimizedModulesArray(node) {
   // Checking whether modules are contained in `Array(<minimum ID>).concat(...modules)` array:
   // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
   // The `<minimum ID>` + array indexes are module ids
-  return node.type === 'CallExpression' && node.callee.type === 'MemberExpression' &&
-  // Make sure the object called is `Array(<some number>)`
-  node.callee.object.type === 'CallExpression' && node.callee.object.callee.type === 'Identifier' && node.callee.object.callee.name === 'Array' && node.callee.object.arguments.length === 1 && isNumericId(node.callee.object.arguments[0]) &&
-  // Make sure the property X called for `Array(<some number>).X` is `concat`
-  node.callee.property.type === 'Identifier' && node.callee.property.name === 'concat' &&
-  // Make sure exactly one array is passed in to `concat`
+  return node.type === 'CallExpression' && node.callee.type === 'MemberExpression' && // Make sure the object called is `Array(<some number>)`
+  node.callee.object.type === 'CallExpression' && node.callee.object.callee.type === 'Identifier' && node.callee.object.callee.name === 'Array' && node.callee.object.arguments.length === 1 && isNumericId(node.callee.object.arguments[0]) && // Make sure the property X called for `Array(<some number>).X` is `concat`
+  node.callee.property.type === 'Identifier' && node.callee.property.name === 'concat' && // Make sure exactly one array is passed in to `concat`
   node.arguments.length === 1 && isModulesArray(node.arguments[0]);
 }
 
 function isModuleWrapper(node) {
-  return (
-    // It's an anonymous function expression that wraps module
-    (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.id ||
-    // If `DedupePlugin` is used it can be an ID of duplicated module...
-    isModuleId(node) ||
-    // or an array of shape [<module_id>, ...args]
+  return (// It's an anonymous function expression that wraps module
+    (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.id || // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) || // or an array of shape [<module_id>, ...args]
     node.type === 'ArrayExpression' && node.elements.length > 1 && isModuleId(node.elements[0])
   );
 }
@@ -143,12 +125,11 @@ function isChunkIds(node) {
 }
 
 function isAsyncChunkPushExpression(node) {
-  var callee = node.callee,
-      args = node.arguments;
-
-
-  return callee.type === 'MemberExpression' && callee.property.name === 'push' && callee.object.type === 'AssignmentExpression' && callee.object.left.object && (callee.object.left.object.name === 'window' ||
-  // Webpack 4 uses `this` instead of `window`
+  const {
+    callee,
+    arguments: args
+  } = node;
+  return callee.type === 'MemberExpression' && callee.property.name === 'push' && callee.object.type === 'AssignmentExpression' && callee.object.left.object && (callee.object.left.object.name === 'window' || // Webpack 4 uses `this` instead of `window`
   callee.object.left.object.type === 'ThisExpression') && args.length === 1 && args[0].type === 'ArrayExpression' && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
 }
 
@@ -159,29 +140,23 @@ function mayBeAsyncChunkArguments(args) {
 function getModulesLocations(node) {
   if (node.type === 'ObjectExpression') {
     // Modules hash
-    var modulesNodes = node.properties;
-
-    return _.transform(modulesNodes, function (result, moduleNode) {
-      var moduleId = moduleNode.key.name || moduleNode.key.value;
-
+    const modulesNodes = node.properties;
+    return _.transform(modulesNodes, (result, moduleNode) => {
+      const moduleId = moduleNode.key.name || moduleNode.key.value;
       result[moduleId] = getModuleLocation(moduleNode.value);
     }, {});
   }
 
-  var isOptimizedArray = node.type === 'CallExpression';
+  const isOptimizedArray = node.type === 'CallExpression';
 
   if (node.type === 'ArrayExpression' || isOptimizedArray) {
     // Modules array or optimized array
-    var minId = isOptimizedArray ?
-    // Get the [minId] value from the Array() call first argument literal value
-    node.callee.object.arguments[0].value :
-    // `0` for simple array
+    const minId = isOptimizedArray ? // Get the [minId] value from the Array() call first argument literal value
+    node.callee.object.arguments[0].value : // `0` for simple array
     0;
-    var _modulesNodes = isOptimizedArray ?
-    // The modules reside in the `concat()` function call arguments
+    const modulesNodes = isOptimizedArray ? // The modules reside in the `concat()` function call arguments
     node.arguments[0].elements : node.elements;
-
-    return _.transform(_modulesNodes, function (result, moduleNode, i) {
+    return _.transform(modulesNodes, (result, moduleNode, i) => {
       if (!moduleNode) return;
       result[i + minId] = getModuleLocation(moduleNode);
     }, {});

package/lib/tree/BaseFolder.js

@@ -1,138 +1,129 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _lodash = _interopRequireDefault(require("lodash"));
 
-var _lodash = require('lodash');
-
-var _lodash2 = _interopRequireDefault(_lodash);
-
-var _Node2 = require('./Node');
-
-var _Node3 = _interopRequireDefault(_Node2);
+var _Node = _interopRequireDefault(require("./Node"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+class BaseFolder extends _Node.default {
+  constructor(name, parent) {
+    super(name, parent);
+    this.children = Object.create(null);
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  get src() {
+    if (!_lodash.default.has(this, '_src')) {
+      this._src = this.walk((node, src) => src += node.src || '', '', false);
+    }
 
-var BaseFolder = function (_Node) {
-  _inherits(BaseFolder, _Node);
+    return this._src;
+  }
 
-  function BaseFolder(name, parent) {
-    _classCallCheck(this, BaseFolder);
+  get size() {
+    if (!_lodash.default.has(this, '_size')) {
+      this._size = this.walk((node, size) => size + node.size, 0, false);
+    }
 
-    var _this = _possibleConstructorReturn(this, (BaseFolder.__proto__ || Object.getPrototypeOf(BaseFolder)).call(this, name, parent));
+    return this._size;
+  }
 
-    _this.children = Object.create(null);
-    return _this;
+  getChild(name) {
+    return this.children[name];
   }
 
-  _createClass(BaseFolder, [{
-    key: 'getChild',
-    value: function getChild(name) {
-      return this.children[name];
+  addChildModule(module) {
+    const {
+      name
+    } = module;
+    const currentChild = this.children[name]; // For some reason we already have this node in children and it's a folder.
+
+    if (currentChild && currentChild instanceof BaseFolder) return;
+
+    if (currentChild) {
+      // We already have this node in children and it's a module.
+      // Merging it's data.
+      currentChild.mergeData(module.data);
+    } else {
+      // Pushing new module
+      module.parent = this;
+      this.children[name] = module;
     }
-  }, {
-    key: 'addChildModule',
-    value: function addChildModule(module) {
-      var name = module.name;
 
-      var currentChild = this.children[name];
+    delete this._size;
+    delete this._src;
+  }
 
-      // For some reason we already have this node in children and it's a folder.
-      if (currentChild && currentChild instanceof BaseFolder) return;
+  addChildFolder(folder) {
+    folder.parent = this;
+    this.children[folder.name] = folder;
+    delete this._size;
+    delete this._src;
+    return folder;
+  }
 
-      if (currentChild) {
-        // We already have this node in children and it's a module.
-        // Merging it's data.
-        currentChild.mergeData(module.data);
+  walk(walker, state = {}, deep = true) {
+    let stopped = false;
+
+    _lodash.default.each(this.children, child => {
+      if (deep && child.walk) {
+        state = child.walk(walker, state, stop);
       } else {
-        // Pushing new module
-        module.parent = this;
-        this.children[name] = module;
+        state = walker(child, state, stop);
       }
 
-      delete this._size;
-      delete this._src;
-    }
-  }, {
-    key: 'addChildFolder',
-    value: function addChildFolder(folder) {
-      folder.parent = this;
-      this.children[folder.name] = folder;
-      delete this._size;
-      delete this._src;
-
-      return folder;
-    }
-  }, {
-    key: 'walk',
-    value: function walk(walker) {
-      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      if (stopped) return false;
+    });
 
-      var stopped = false;
+    return state;
 
-      _lodash2.default.each(this.children, function (child) {
-        if (deep && child.walk) {
-          state = child.walk(walker, state, stop);
-        } else {
-          state = walker(child, state, stop);
-        }
+    function stop(finalState) {
+      stopped = true;
+      return finalState;
+    }
+  }
 
-        if (stopped) return false;
-      });
+  mergeNestedFolders() {
+    if (!this.isRoot) {
+      let childNames;
 
-      return state;
+      while ((childNames = Object.keys(this.children)).length === 1) {
+        const childName = childNames[0];
+        const onlyChild = this.children[childName];
 
-      function stop(finalState) {
-        stopped = true;
-        return finalState;
+        if (onlyChild instanceof this.constructor) {
+          this.name += `/${onlyChild.name}`;
+          this.children = onlyChild.children;
+        } else {
+          break;
+        }
       }
     }
-  }, {
-    key: 'toChartData',
-    value: function toChartData() {
-      return {
-        label: this.name,
-        path: this.path,
-        statSize: this.size,
-        groups: _lodash2.default.invokeMap(this.children, 'toChartData')
-      };
-    }
-  }, {
-    key: 'src',
-    get: function get() {
-      if (!_lodash2.default.has(this, '_src')) {
-        this._src = this.walk(function (node, src) {
-          return src += node.src || '';
-        }, '', false);
-      }
 
-      return this._src;
-    }
-  }, {
-    key: 'size',
-    get: function get() {
-      if (!_lodash2.default.has(this, '_size')) {
-        this._size = this.walk(function (node, size) {
-          return size + node.size;
-        }, 0, false);
+    this.walk(child => {
+      child.parent = this;
+
+      if (child.mergeNestedFolders) {
+        child.mergeNestedFolders();
       }
+    }, null, false);
+  }
 
-      return this._size;
-    }
-  }]);
+  toChartData() {
+    return {
+      label: this.name,
+      path: this.path,
+      statSize: this.size,
+      groups: _lodash.default.invokeMap(this.children, 'toChartData')
+    };
+  }
 
-  return BaseFolder;
-}(_Node3.default);
+}
 
 exports.default = BaseFolder;
 ;