webpack 3.6.0 → 3.8.1

package/lib/node/NodeSourcePlugin.js

@@ -1,88 +1,88 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
-const ParserHelpers = require("../ParserHelpers");
-const nodeLibsBrowser = require("node-libs-browser");
-
-module.exports = class NodeSourcePlugin {
-	constructor(options) {
-		this.options = options;
-	}
-	apply(compiler) {
-		const options = this.options;
-		if(options === false) // allow single kill switch to turn off this plugin
-			return;
-
-		function getPathToModule(module, type) {
-			if(type === true || (type === undefined && nodeLibsBrowser[module])) {
-				if(!nodeLibsBrowser[module]) throw new Error(`No browser version for node.js core module ${module} available`);
-				return nodeLibsBrowser[module];
-			} else if(type === "mock") {
-				return require.resolve(`node-libs-browser/mock/${module}`);
-			} else if(type === "empty") {
-				return require.resolve("node-libs-browser/mock/empty");
-			} else return module;
-		}
-
-		function addExpression(parser, name, module, type, suffix) {
-			suffix = suffix || "";
-			parser.plugin(`expression ${name}`, function() {
-				if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
-				const mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
-				return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
-			});
-		}
-
-		compiler.plugin("compilation", function(compilation, params) {
-			params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
-
-				if(parserOptions.node === false)
-					return;
-
-				let localOptions = options;
-				if(parserOptions.node)
-					localOptions = Object.assign({}, localOptions, parserOptions.node);
-
-				if(localOptions.global) {
-					parser.plugin("expression global", function() {
-						const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
-						return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
-					});
-				}
-				if(localOptions.process) {
-					const processType = localOptions.process;
-					addExpression(parser, "process", "process", processType);
-				}
-				if(localOptions.console) {
-					const consoleType = localOptions.console;
-					addExpression(parser, "console", "console", consoleType);
-				}
-				const bufferType = localOptions.Buffer;
-				if(bufferType) {
-					addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
-				}
-				if(localOptions.setImmediate) {
-					const setImmediateType = localOptions.setImmediate;
-					addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
-					addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
-				}
-			});
-		});
-		compiler.plugin("after-resolvers", (compiler) => {
-			Object.keys(nodeLibsBrowser).forEach((lib) => {
-				if(options[lib] !== false) {
-					compiler.resolvers.normal.apply(
-						new AliasPlugin("described-resolve", {
-							name: lib,
-							onlyModule: true,
-							alias: getPathToModule(lib, options[lib])
-						}, "resolve")
-					);
-				}
-			});
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
+const ParserHelpers = require("../ParserHelpers");
+const nodeLibsBrowser = require("node-libs-browser");
+
+module.exports = class NodeSourcePlugin {
+	constructor(options) {
+		this.options = options;
+	}
+	apply(compiler) {
+		const options = this.options;
+		if(options === false) // allow single kill switch to turn off this plugin
+			return;
+
+		function getPathToModule(module, type) {
+			if(type === true || (type === undefined && nodeLibsBrowser[module])) {
+				if(!nodeLibsBrowser[module]) throw new Error(`No browser version for node.js core module ${module} available`);
+				return nodeLibsBrowser[module];
+			} else if(type === "mock") {
+				return require.resolve(`node-libs-browser/mock/${module}`);
+			} else if(type === "empty") {
+				return require.resolve("node-libs-browser/mock/empty");
+			} else return module;
+		}
+
+		function addExpression(parser, name, module, type, suffix) {
+			suffix = suffix || "";
+			parser.plugin(`expression ${name}`, function() {
+				if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
+				const mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
+				return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
+			});
+		}
+
+		compiler.plugin("compilation", function(compilation, params) {
+			params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+				if(parserOptions.node === false)
+					return;
+
+				let localOptions = options;
+				if(parserOptions.node)
+					localOptions = Object.assign({}, localOptions, parserOptions.node);
+
+				if(localOptions.global) {
+					parser.plugin("expression global", function() {
+						const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
+						return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
+					});
+				}
+				if(localOptions.process) {
+					const processType = localOptions.process;
+					addExpression(parser, "process", "process", processType);
+				}
+				if(localOptions.console) {
+					const consoleType = localOptions.console;
+					addExpression(parser, "console", "console", consoleType);
+				}
+				const bufferType = localOptions.Buffer;
+				if(bufferType) {
+					addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
+				}
+				if(localOptions.setImmediate) {
+					const setImmediateType = localOptions.setImmediate;
+					addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
+					addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
+				}
+			});
+		});
+		compiler.plugin("after-resolvers", (compiler) => {
+			Object.keys(nodeLibsBrowser).forEach((lib) => {
+				if(options[lib] !== false) {
+					compiler.resolvers.normal.apply(
+						new AliasPlugin("described-resolve", {
+							name: lib,
+							onlyModule: true,
+							alias: getPathToModule(lib, options[lib])
+						}, "resolve")
+					);
+				}
+			});
+		});
+	}
+};

package/lib/node/NodeTargetPlugin.js

@@ -1,15 +1,15 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ExternalsPlugin = require("../ExternalsPlugin");
-
-class NodeTargetPlugin {
-	apply(compiler) {
-		new ExternalsPlugin("commonjs", Object.keys(process.binding("natives"))).apply(compiler);
-	}
-}
-
-module.exports = NodeTargetPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ExternalsPlugin = require("../ExternalsPlugin");
+
+class NodeTargetPlugin {
+	apply(compiler) {
+		new ExternalsPlugin("commonjs", Object.keys(process.binding("natives"))).apply(compiler);
+	}
+}
+
+module.exports = NodeTargetPlugin;

package/lib/node/NodeTemplatePlugin.js

@@ -1,27 +1,27 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const NodeMainTemplatePlugin = require("./NodeMainTemplatePlugin");
-const NodeChunkTemplatePlugin = require("./NodeChunkTemplatePlugin");
-const NodeHotUpdateChunkTemplatePlugin = require("./NodeHotUpdateChunkTemplatePlugin");
-
-class NodeTemplatePlugin {
-	constructor(options) {
-		options = options || {};
-		this.asyncChunkLoading = options.asyncChunkLoading;
-	}
-
-	apply(compiler) {
-		compiler.plugin("this-compilation", (compilation) => {
-			compilation.mainTemplate.apply(new NodeMainTemplatePlugin(this.asyncChunkLoading));
-			compilation.chunkTemplate.apply(new NodeChunkTemplatePlugin());
-			compilation.hotUpdateChunkTemplate.apply(new NodeHotUpdateChunkTemplatePlugin());
-		});
-	}
-}
-
-module.exports = NodeTemplatePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const NodeMainTemplatePlugin = require("./NodeMainTemplatePlugin");
+const NodeChunkTemplatePlugin = require("./NodeChunkTemplatePlugin");
+const NodeHotUpdateChunkTemplatePlugin = require("./NodeHotUpdateChunkTemplatePlugin");
+
+class NodeTemplatePlugin {
+	constructor(options) {
+		options = options || {};
+		this.asyncChunkLoading = options.asyncChunkLoading;
+	}
+
+	apply(compiler) {
+		compiler.plugin("this-compilation", (compilation) => {
+			compilation.mainTemplate.apply(new NodeMainTemplatePlugin(this.asyncChunkLoading));
+			compilation.chunkTemplate.apply(new NodeChunkTemplatePlugin());
+			compilation.hotUpdateChunkTemplate.apply(new NodeHotUpdateChunkTemplatePlugin());
+		});
+	}
+}
+
+module.exports = NodeTemplatePlugin;

package/lib/node/NodeWatchFileSystem.js

@@ -1,72 +1,72 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Watchpack = require("watchpack");
-
-class NodeWatchFileSystem {
-	constructor(inputFileSystem) {
-		this.inputFileSystem = inputFileSystem;
-		this.watcherOptions = {
-			aggregateTimeout: 0
-		};
-		this.watcher = new Watchpack(this.watcherOptions);
-	}
-
-	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
-		if(!Array.isArray(files))
-			throw new Error("Invalid arguments: 'files'");
-		if(!Array.isArray(dirs))
-			throw new Error("Invalid arguments: 'dirs'");
-		if(!Array.isArray(missing))
-			throw new Error("Invalid arguments: 'missing'");
-		if(typeof callback !== "function")
-			throw new Error("Invalid arguments: 'callback'");
-		if(typeof startTime !== "number" && startTime)
-			throw new Error("Invalid arguments: 'startTime'");
-		if(typeof options !== "object")
-			throw new Error("Invalid arguments: 'options'");
-		if(typeof callbackUndelayed !== "function" && callbackUndelayed)
-			throw new Error("Invalid arguments: 'callbackUndelayed'");
-		const oldWatcher = this.watcher;
-		this.watcher = new Watchpack(options);
-
-		if(callbackUndelayed)
-			this.watcher.once("change", callbackUndelayed);
-
-		this.watcher.once("aggregated", (changes, removals) => {
-			changes = changes.concat(removals);
-			if(this.inputFileSystem && this.inputFileSystem.purge) {
-				this.inputFileSystem.purge(changes);
-			}
-			const times = this.watcher.getTimes();
-			callback(null,
-				changes.filter(file => files.indexOf(file) >= 0).sort(),
-				changes.filter(file => dirs.indexOf(file) >= 0).sort(),
-				changes.filter(file => missing.indexOf(file) >= 0).sort(), times, times);
-		});
-
-		this.watcher.watch(files.concat(missing), dirs.concat(missing), startTime);
-
-		if(oldWatcher) {
-			oldWatcher.close();
-		}
-		return {
-			close: () => {
-				if(this.watcher) {
-					this.watcher.close();
-					this.watcher = null;
-				}
-			},
-			pause: () => {
-				if(this.watcher) {
-					this.watcher.pause();
-				}
-			}
-		};
-	}
-}
-
-module.exports = NodeWatchFileSystem;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Watchpack = require("watchpack");
+
+class NodeWatchFileSystem {
+	constructor(inputFileSystem) {
+		this.inputFileSystem = inputFileSystem;
+		this.watcherOptions = {
+			aggregateTimeout: 0
+		};
+		this.watcher = new Watchpack(this.watcherOptions);
+	}
+
+	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
+		if(!Array.isArray(files))
+			throw new Error("Invalid arguments: 'files'");
+		if(!Array.isArray(dirs))
+			throw new Error("Invalid arguments: 'dirs'");
+		if(!Array.isArray(missing))
+			throw new Error("Invalid arguments: 'missing'");
+		if(typeof callback !== "function")
+			throw new Error("Invalid arguments: 'callback'");
+		if(typeof startTime !== "number" && startTime)
+			throw new Error("Invalid arguments: 'startTime'");
+		if(typeof options !== "object")
+			throw new Error("Invalid arguments: 'options'");
+		if(typeof callbackUndelayed !== "function" && callbackUndelayed)
+			throw new Error("Invalid arguments: 'callbackUndelayed'");
+		const oldWatcher = this.watcher;
+		this.watcher = new Watchpack(options);
+
+		if(callbackUndelayed)
+			this.watcher.once("change", callbackUndelayed);
+
+		this.watcher.once("aggregated", (changes, removals) => {
+			changes = changes.concat(removals);
+			if(this.inputFileSystem && this.inputFileSystem.purge) {
+				this.inputFileSystem.purge(changes);
+			}
+			const times = this.watcher.getTimes();
+			callback(null,
+				changes.filter(file => files.indexOf(file) >= 0).sort(),
+				changes.filter(file => dirs.indexOf(file) >= 0).sort(),
+				changes.filter(file => missing.indexOf(file) >= 0).sort(), times, times);
+		});
+
+		this.watcher.watch(files.concat(missing), dirs.concat(missing), startTime);
+
+		if(oldWatcher) {
+			oldWatcher.close();
+		}
+		return {
+			close: () => {
+				if(this.watcher) {
+					this.watcher.close();
+					this.watcher = null;
+				}
+			},
+			pause: () => {
+				if(this.watcher) {
+					this.watcher.pause();
+				}
+			}
+		};
+	}
+}
+
+module.exports = NodeWatchFileSystem;

package/lib/optimize/ChunkModuleIdRangePlugin.js

@@ -1,53 +1,53 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-class ChunkModuleIdRangePlugin {
-	constructor(options) {
-		this.options = options;
-	}
-	apply(compiler) {
-		const options = this.options;
-		compiler.plugin("compilation", (compilation) => {
-			compilation.plugin("module-ids", (modules) => {
-				const chunk = this.chunks.find((chunk) => chunk.name === options.name);
-				if(!chunk) throw new Error("ChunkModuleIdRangePlugin: Chunk with name '" + options.name + "' was not found");
-				let currentId = options.start;
-				let chunkModules;
-				if(options.order) {
-					chunkModules = chunk.modules.slice();
-					switch(options.order) {
-						case "index":
-							chunkModules.sort((a, b) => {
-								return a.index - b.index;
-							});
-							break;
-						case "index2":
-							chunkModules.sort((a, b) => {
-								return a.index2 - b.index2;
-							});
-							break;
-						default:
-							throw new Error("ChunkModuleIdRangePlugin: unexpected value of order");
-					}
-
-				} else {
-					chunkModules = modules.filter((m) => {
-						return m.chunks.indexOf(chunk) >= 0;
-					});
-				}
-
-				for(let i = 0; i < chunkModules.length; i++) {
-					const m = chunkModules[i];
-					if(m.id === null) {
-						m.id = currentId++;
-					}
-					if(options.end && currentId > options.end)
-						break;
-				}
-			});
-		});
-	}
-}
-module.exports = ChunkModuleIdRangePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+class ChunkModuleIdRangePlugin {
+	constructor(options) {
+		this.options = options;
+	}
+	apply(compiler) {
+		const options = this.options;
+		compiler.plugin("compilation", (compilation) => {
+			compilation.plugin("module-ids", (modules) => {
+				const chunk = this.chunks.find((chunk) => chunk.name === options.name);
+				if(!chunk) throw new Error("ChunkModuleIdRangePlugin: Chunk with name '" + options.name + "' was not found");
+				let currentId = options.start;
+				let chunkModules;
+				if(options.order) {
+					chunkModules = chunk.modules.slice();
+					switch(options.order) {
+						case "index":
+							chunkModules.sort((a, b) => {
+								return a.index - b.index;
+							});
+							break;
+						case "index2":
+							chunkModules.sort((a, b) => {
+								return a.index2 - b.index2;
+							});
+							break;
+						default:
+							throw new Error("ChunkModuleIdRangePlugin: unexpected value of order");
+					}
+
+				} else {
+					chunkModules = modules.filter((m) => {
+						return m.chunks.indexOf(chunk) >= 0;
+					});
+				}
+
+				for(let i = 0; i < chunkModules.length; i++) {
+					const m = chunkModules[i];
+					if(m.id === null) {
+						m.id = currentId++;
+					}
+					if(options.end && currentId > options.end)
+						break;
+				}
+			});
+		});
+	}
+}
+module.exports = ChunkModuleIdRangePlugin;

package/lib/optimize/CommonsChunkPlugin.js

@@ -4,6 +4,7 @@
 */
 "use strict";
 let nextIdent = 0;
+
 class CommonsChunkPlugin {
 	constructor(options) {
 		if(arguments.length > 1) {
@@ -31,6 +32,7 @@ The available options are:
 		this.minChunks = normalizedOptions.minChunks;
 		this.selectedChunks = normalizedOptions.selectedChunks;
 		this.children = normalizedOptions.children;
+		this.deepChildren = normalizedOptions.deepChildren;
 		this.async = normalizedOptions.async;
 		this.minSize = normalizedOptions.minSize;
 		this.ident = __filename + (nextIdent++);
@@ -76,6 +78,7 @@ You can however specify the name of the async chunk by passing the desired strin
 			minChunks: options.minChunks,
 			selectedChunks: options.chunks,
 			children: options.children,
+			deepChildren: options.deepChildren,
 			async: options.async,
 			minSize: options.minSize
 		};
@@ -104,7 +107,7 @@ You can however specify the name of the async chunk by passing the desired strin
 					/**
 					 * These chunks are subject to get "common" modules extracted and moved to the common chunk
 					 */
-					const affectedChunks = this.getAffectedChunks(compilation, chunks, targetChunk, targetChunks, idx, this.selectedChunks, this.async, this.children);
+					const affectedChunks = this.getAffectedChunks(compilation, chunks, targetChunk, targetChunks, idx, this.selectedChunks, this.async, this.children, this.deepChildren);
 
 					// bail if no chunk is affected
 					if(!affectedChunks) {
@@ -211,8 +214,39 @@ You can however specify the name of the async chunk by passing the desired strin
 Take a look at the "name"/"names" or async/children option.`);
 	}
 
-	getAffectedChunks(compilation, allChunks, targetChunk, targetChunks, currentIndex, selectedChunks, asyncOption, children) {
-		const asyncOrNoSelectedChunk = children || asyncOption;
+	getAffectedUnnamedChunks(affectedChunks, targetChunk, rootChunk, asyncOption, deepChildrenOption) {
+		let chunks = targetChunk.chunks;
+		chunks && chunks.forEach((chunk) => {
+			if(chunk.isInitial()) {
+				return;
+			}
+			// If all the parents of a chunk are either
+			// a) the target chunk we started with
+			// b) themselves affected chunks
+			// we can assume that this chunk is an affected chunk too, as there is no way a chunk that
+			// isn't only depending on the target chunk is a parent of the chunk tested
+			if(asyncOption || chunk.parents.every((parentChunk) => parentChunk === rootChunk || affectedChunks.has(parentChunk))) {
+				// This check not only dedupes the affectedChunks but also guarantees we avoid endless loops
+				if(!affectedChunks.has(chunk)) {
+					// We mutate the affected chunks before going deeper, so the deeper levels and other branches
+					// have the information of this chunk being affected for their assertion if a chunk should
+					// not be affected
+					affectedChunks.add(chunk);
+
+					// We recurse down to all the children of the chunk, applying the same assumption.
+					// This guarantees that if a chunk should be an affected chunk,
+					// at the latest the last connection to the same chunk meets the
+					// condition to add it to the affected chunks.
+					if(deepChildrenOption === true) {
+						this.getAffectedUnnamedChunks(affectedChunks, chunk, rootChunk, asyncOption, deepChildrenOption);
+					}
+				}
+			}
+		});
+	}
+
+	getAffectedChunks(compilation, allChunks, targetChunk, targetChunks, currentIndex, selectedChunks, asyncOption, childrenOption, deepChildrenOption) {
+		const asyncOrNoSelectedChunk = childrenOption || asyncOption;
 
 		if(Array.isArray(selectedChunks)) {
 			return allChunks.filter(chunk => {
@@ -223,22 +257,9 @@ Take a look at the "name"/"names" or async/children option.`);
 		}
 
 		if(asyncOrNoSelectedChunk) {
-			// nothing to do here
-			if(!targetChunk.chunks) {
-				return [];
-			}
-
-			return targetChunk.chunks.filter((chunk) => {
-				// we only are interested in on-demand chunks
-				if(chunk.isInitial())
-					return false;
-
-				// we can only move modules from this chunk if the "commonChunk" is the only parent
-				if(!asyncOption)
-					return chunk.parents.length === 1;
-
-				return true;
-			});
+			let affectedChunks = new Set();
+			this.getAffectedUnnamedChunks(affectedChunks, targetChunk, targetChunk, asyncOption, deepChildrenOption);
+			return Array.from(affectedChunks);
 		}
 
 		/**