node_modules

node_modules/webpack-bundle-analyzer/src/tree/BaseFolder.js

@@ -0,0 +1,118 @@
+import _ from 'lodash';
+
+import Node from './Node';
+
+export default class BaseFolder extends Node {
+
+  constructor(name, parent) {
+    super(name, parent);
+    this.children = Object.create(null);
+  }
+
+  get src() {
+    if (!_.has(this, '_src')) {
+      this._src = this.walk((node, src) => (src += node.src || ''), '', false);
+    }
+
+    return this._src;
+  }
+
+  get size() {
+    if (!_.has(this, '_size')) {
+      this._size = this.walk((node, size) => (size + node.size), 0, false);
+    }
+
+    return this._size;
+  }
+
+  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;
+    }
+
+    delete this._size;
+    delete this._src;
+  }
+
+  addChildFolder(folder) {
+    folder.parent = this;
+    this.children[folder.name] = folder;
+    delete this._size;
+    delete this._src;
+
+    return folder;
+  }
+
+  walk(walker, state = {}, deep = true) {
+    let stopped = false;
+
+    _.each(this.children, child => {
+      if (deep && child.walk) {
+        state = child.walk(walker, state, stop);
+      } else {
+        state = walker(child, state, stop);
+      }
+
+      if (stopped) return false;
+    });
+
+    return state;
+
+    function stop(finalState) {
+      stopped = true;
+      return finalState;
+    }
+  }
+
+  mergeNestedFolders() {
+    if (!this.isRoot) {
+      let childNames;
+
+      while ((childNames = Object.keys(this.children)).length === 1) {
+        const childName = childNames[0];
+        const onlyChild = this.children[childName];
+
+        if (onlyChild instanceof this.constructor) {
+          this.name += `/${onlyChild.name}`;
+          this.children = onlyChild.children;
+        } else {
+          break;
+        }
+      }
+    }
+
+    this.walk(child => {
+      child.parent = this;
+
+      if (child.mergeNestedFolders) {
+        child.mergeNestedFolders();
+      }
+    }, null, false);
+  }
+
+  toChartData() {
+    return {
+      label: this.name,
+      path: this.path,
+      statSize: this.size,
+      groups: _.invokeMap(this.children, 'toChartData')
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/ConcatenatedModule.js

@@ -0,0 +1,72 @@
+import _ from 'lodash';
+
+import Module from './Module';
+import ContentModule from './ContentModule';
+import ContentFolder from './ContentFolder';
+import {getModulePathParts} from './utils';
+
+export default class ConcatenatedModule extends Module {
+
+  constructor(name, data, parent) {
+    super(name, data, parent);
+    this.name += ' (concatenated)';
+    this.children = Object.create(null);
+    this.fillContentModules();
+  }
+
+  fillContentModules() {
+    _.each(this.data.modules, moduleData => this.addContentModule(moduleData));
+  }
+
+  addContentModule(moduleData) {
+    const pathParts = getModulePathParts(moduleData);
+
+    if (!pathParts) {
+      return;
+    }
+
+    const [folders, fileName] = [pathParts.slice(0, -1), _.last(pathParts)];
+    let currentFolder = this;
+
+    _.each(folders, folderName => {
+      let childFolder = currentFolder.getChild(folderName);
+
+      if (!childFolder) {
+        childFolder = currentFolder.addChildFolder(new ContentFolder(folderName, this));
+      }
+
+      currentFolder = childFolder;
+    });
+
+    const module = new ContentModule(fileName, moduleData, this);
+    currentFolder.addChildModule(module);
+  }
+
+  getChild(name) {
+    return this.children[name];
+  }
+
+  addChildModule(module) {
+    module.parent = this;
+    this.children[module.name] = module;
+  }
+
+  addChildFolder(folder) {
+    folder.parent = this;
+    this.children[folder.name] = folder;
+    return folder;
+  }
+
+  mergeNestedFolders() {
+    _.invokeMap(this.children, 'mergeNestedFolders');
+  }
+
+  toChartData() {
+    return {
+      ...super.toChartData(),
+      concatenated: true,
+      groups: _.invokeMap(this.children, 'toChartData')
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/ContentFolder.js

@@ -0,0 +1,35 @@
+import BaseFolder from './BaseFolder';
+
+export default class ContentFolder extends BaseFolder {
+
+  constructor(name, ownerModule, parent) {
+    super(name, parent);
+    this.ownerModule = ownerModule;
+  }
+
+  get parsedSize() {
+    return this.getSize('parsedSize');
+  }
+
+  get gzipSize() {
+    return this.getSize('gzipSize');
+  }
+
+  getSize(sizeType) {
+    const ownerModuleSize = this.ownerModule[sizeType];
+
+    if (ownerModuleSize !== undefined) {
+      return Math.floor((this.size / this.ownerModule.size) * ownerModuleSize);
+    }
+  }
+
+  toChartData() {
+    return {
+      ...super.toChartData(),
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize,
+      inaccurateSizes: true
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/ContentModule.js

@@ -0,0 +1,33 @@
+import Module from './Module';
+
+export default class ContentModule extends Module {
+
+  constructor(name, data, ownerModule, parent) {
+    super(name, data, parent);
+    this.ownerModule = ownerModule;
+  }
+
+  get parsedSize() {
+    return this.getSize('parsedSize');
+  }
+
+  get gzipSize() {
+    return this.getSize('gzipSize');
+  }
+
+  getSize(sizeType) {
+    const ownerModuleSize = this.ownerModule[sizeType];
+
+    if (ownerModuleSize !== undefined) {
+      return Math.floor((this.size / this.ownerModule.size) * ownerModuleSize);
+    }
+  }
+
+  toChartData() {
+    return {
+      ...super.toChartData(),
+      inaccurateSizes: true
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/Folder.js

@@ -0,0 +1,64 @@
+import _ from 'lodash';
+import gzipSize from 'gzip-size';
+
+import Module from './Module';
+import BaseFolder from './BaseFolder';
+import ConcatenatedModule from './ConcatenatedModule';
+import {getModulePathParts} from './utils';
+
+export default class Folder extends BaseFolder {
+
+  get parsedSize() {
+    return this.src ? this.src.length : 0;
+  }
+
+  get gzipSize() {
+    if (!_.has(this, '_gzipSize')) {
+      this._gzipSize = this.src ? gzipSize.sync(this.src) : 0;
+    }
+
+    return this._gzipSize;
+  }
+
+  addModule(moduleData) {
+    const pathParts = getModulePathParts(moduleData);
+
+    if (!pathParts) {
+      return;
+    }
+
+    const [folders, fileName] = [pathParts.slice(0, -1), _.last(pathParts)];
+    let currentFolder = this;
+
+    _.each(folders, folderName => {
+      let childNode = currentFolder.getChild(folderName);
+
+      if (
+        // Folder is not created yet
+        !childNode ||
+        // In some situations (invalid usage of dynamic `require()`) webpack generates a module with empty require
+        // context, but it's moduleId points to a directory in filesystem.
+        // In this case we replace this `File` node with `Folder`.
+        // See `test/stats/with-invalid-dynamic-require.json` as an example.
+        !(childNode instanceof Folder)
+      ) {
+        childNode = currentFolder.addChildFolder(new Folder(folderName));
+      }
+
+      currentFolder = childNode;
+    });
+
+    const ModuleConstructor = moduleData.modules ? ConcatenatedModule : Module;
+    const module = new ModuleConstructor(fileName, moduleData, this);
+    currentFolder.addChildModule(module);
+  }
+
+  toChartData() {
+    return {
+      ...super.toChartData(),
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/Module.js

@@ -0,0 +1,63 @@
+import _ from 'lodash';
+import gzipSize from 'gzip-size';
+
+import Node from './Node';
+
+export default class Module extends Node {
+
+  constructor(name, data, parent) {
+    super(name, parent);
+    this.data = data;
+  }
+
+  get src() {
+    return this.data.parsedSrc;
+  }
+
+  set src(value) {
+    this.data.parsedSrc = value;
+    delete this._gzipSize;
+  }
+
+  get size() {
+    return this.data.size;
+  }
+
+  set size(value) {
+    this.data.size = value;
+  }
+
+  get parsedSize() {
+    return this.src ? this.src.length : undefined;
+  }
+
+  get gzipSize() {
+    if (!_.has(this, '_gzipSize')) {
+      this._gzipSize = this.src ? gzipSize.sync(this.src) : undefined;
+    }
+
+    return this._gzipSize;
+  }
+
+  mergeData(data) {
+    if (data.size) {
+      this.size += data.size;
+    }
+
+    if (data.parsedSrc) {
+      this.src = (this.src || '') + data.parsedSrc;
+    }
+  }
+
+  toChartData() {
+    return {
+      id: this.data.id,
+      label: this.name,
+      path: this.path,
+      statSize: this.size,
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize
+    };
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/Node.js

@@ -0,0 +1,24 @@
+export default class Node {
+
+  constructor(name, parent) {
+    this.name = name;
+    this.parent = parent;
+  }
+
+  get path() {
+    const path = [];
+    let node = this;
+
+    while (node) {
+      path.push(node.name);
+      node = node.parent;
+    }
+
+    return path.reverse().join('/');
+  }
+
+  get isRoot() {
+    return !this.parent;
+  }
+
+};

node_modules/webpack-bundle-analyzer/src/tree/utils.js

@@ -0,0 +1,21 @@
+import _ from 'lodash';
+
+const MULTI_MODULE_REGEXP = /^multi /u;
+
+export function getModulePathParts(moduleData) {
+  if (MULTI_MODULE_REGEXP.test(moduleData.identifier)) {
+    return [moduleData.identifier];
+  }
+
+  const parsedPath = _
+  // Removing loaders from module path: they're joined by `!` and the last part is a raw module path
+    .last(moduleData.name.split('!'))
+    // Splitting module path into parts
+    .split('/')
+    // Removing first `.`
+    .slice(1)
+    // Replacing `~` with `node_modules`
+    .map(part => (part === '~' ? 'node_modules' : part));
+
+  return parsedPath.length ? parsedPath : null;
+}