webpack 4.20.2 → 4.23.1

package/lib/Compilation.js

@@ -88,12 +88,6 @@ const compareLocations = require("./compareLocations");
  * @property {Dependency[]} dependencies
  */
 
-/**
- * @typedef {Object} AvailableModulesChunkGroupMapping
- * @property {ChunkGroup} chunkGroup
- * @property {Set<Module>} availableModules
- */
-
 /**
  * @typedef {Object} DependenciesBlockLike
  * @property {Dependency[]} dependencies
@@ -107,10 +101,11 @@ const compareLocations = require("./compareLocations");
  * @returns {-1|0|1} sort value
  */
 const byId = (a, b) => {
-	if (a.id !== null && b.id !== null) {
-		if (a.id < b.id) return -1;
-		if (a.id > b.id) return 1;
+	if (typeof a.id !== typeof b.id) {
+		return typeof a.id < typeof b.id ? -1 : 1;
 	}
+	if (a.id < b.id) return -1;
+	if (a.id > b.id) return 1;
 	return 0;
 };
 
@@ -120,6 +115,9 @@ const byId = (a, b) => {
  * @returns {-1|0|1} sort value
  */
 const byIdOrIdentifier = (a, b) => {
+	if (typeof a.id !== typeof b.id) {
+		return typeof a.id < typeof b.id ? -1 : 1;
+	}
 	if (a.id < b.id) return -1;
 	if (a.id > b.id) return 1;
 	const identA = a.identifier();
@@ -157,6 +155,16 @@ const byNameOrHash = (a, b) => {
 	return 0;
 };
 
+/**
+ * @template T
+ * @param {Set<T>} a first set
+ * @param {Set<T>} b second set
+ * @returns {number} cmp
+ */
+const bySetSize = (a, b) => {
+	return a.size - b.size;
+};
+
 /**
  * @param {DependenciesBlockVariable[]} variables DepBlock Variables to iterate over
  * @param {DepBlockVarDependenciesCallback} fn callback to apply on iterated elements
@@ -644,7 +652,15 @@ class Compilation extends Tapable {
 					war.dependencies = dependencies;
 					this.warnings.push(war);
 				}
-				module.dependencies.sort((a, b) => compareLocations(a.loc, b.loc));
+				const originalMap = module.dependencies.reduce((map, v, i) => {
+					map.set(v, i);
+					return map;
+				}, new Map());
+				module.dependencies.sort((a, b) => {
+					const cmp = compareLocations(a.loc, b.loc);
+					if (cmp) return cmp;
+					return originalMap.get(a) - originalMap.get(b);
+				});
 				if (error) {
 					this.hooks.failedModule.call(module, error);
 					return callback(error);
@@ -1491,7 +1507,7 @@ class Compilation extends Tapable {
 		//   eachother and Blocks with Chunks. It stops traversing when all modules
 		//   for a chunk are already available. So it doesn't connect unneeded chunks.
 
-		/** @type {Map<ChunkGroup, {block: AsyncDependenciesBlock, chunkGroup: ChunkGroup}[]>} */
+		/** @type {Map<ChunkGroup, {block: AsyncDependenciesBlock, chunkGroup: ChunkGroup, couldBeFiltered: boolean}[]>} */
 		const chunkDependencies = new Map();
 		const allCreatedChunkGroups = new Set();
 
@@ -1664,7 +1680,8 @@ class Compilation extends Tapable {
 			if (!deps) chunkDependencies.set(chunkGroup, (deps = []));
 			deps.push({
 				block: b,
-				chunkGroup: c
+				chunkGroup: c,
+				couldBeFiltered: true
 			});
 
 			// 3. We enqueue the DependenciesBlock for traversal
@@ -1777,15 +1794,26 @@ class Compilation extends Tapable {
 
 		// PART TWO
 		/** @type {Set<Module>} */
-		let availableModules;
 		let newAvailableModules;
-		/** @type {Queue<AvailableModulesChunkGroupMapping>} */
-		const queue2 = new Queue(
-			inputChunkGroups.map(chunkGroup => ({
-				chunkGroup,
-				availableModules: new Set()
-			}))
-		);
+
+		/**
+		 * @typedef {Object} ChunkGroupInfo
+		 * @property {Set<Module>} minAvailableModules current minimal set of modules available at this point
+		 * @property {Set<Module>[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
+		 */
+
+		/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
+		const chunkGroupInfoMap = new Map();
+
+		/** @type {Queue<ChunkGroup>} */
+		const queue2 = new Queue(inputChunkGroups);
+
+		for (const chunkGroup of inputChunkGroups) {
+			chunkGroupInfoMap.set(chunkGroup, {
+				minAvailableModules: undefined,
+				availableModulesToBeMerged: [new Set()]
+			});
+		}
 
 		/**
 		 * Helper function to check if all modules of a chunk are available
@@ -1811,38 +1839,44 @@ class Compilation extends Tapable {
 		 */
 		const filterFn = dep => {
 			const depChunkGroup = dep.chunkGroup;
+			if (!dep.couldBeFiltered) return true;
 			if (blocksWithNestedBlocks.has(dep.block)) return true;
-			if (areModulesAvailable(depChunkGroup, newAvailableModules)) return false; // break all modules are already available
+			if (areModulesAvailable(depChunkGroup, newAvailableModules)) {
+				return false; // break all modules are already available
+			}
+			dep.couldBeFiltered = false;
 			return true;
 		};
 
-		/** @type {Map<ChunkGroup, Set<Module>>} */
-		const minAvailableModulesMap = new Map();
-
 		// Iterative traversing of the basic chunk graph
 		while (queue2.length) {
-			const queueItem = queue2.dequeue();
-			chunkGroup = queueItem.chunkGroup;
-			availableModules = queueItem.availableModules;
+			chunkGroup = queue2.dequeue();
+			const info = chunkGroupInfoMap.get(chunkGroup);
+			const availableModulesToBeMerged = info.availableModulesToBeMerged;
+			let minAvailableModules = info.minAvailableModules;
 
 			// 1. Get minimal available modules
 			// It doesn't make sense to traverse a chunk again with more available modules.
 			// This step calculates the minimal available modules and skips traversal when
 			// the list didn't shrink.
-			let minAvailableModules = minAvailableModulesMap.get(chunkGroup);
-			if (minAvailableModules === undefined) {
-				minAvailableModulesMap.set(chunkGroup, new Set(availableModules));
-			} else {
-				let deletedModules = false;
-				for (const m of minAvailableModules) {
-					if (!availableModules.has(m)) {
-						minAvailableModules.delete(m);
-						deletedModules = true;
+			availableModulesToBeMerged.sort(bySetSize);
+			let changed = false;
+			for (const availableModules of availableModulesToBeMerged) {
+				if (minAvailableModules === undefined) {
+					minAvailableModules = new Set(availableModules);
+					info.minAvailableModules = minAvailableModules;
+					changed = true;
+				} else {
+					for (const m of minAvailableModules) {
+						if (!availableModules.has(m)) {
+							minAvailableModules.delete(m);
+							changed = true;
+						}
 					}
 				}
-				if (!deletedModules) continue;
-				availableModules = minAvailableModules;
 			}
+			availableModulesToBeMerged.length = 0;
+			if (!changed) continue;
 
 			// 2. Get the edges at this point of the graph
 			const deps = chunkDependencies.get(chunkGroup);
@@ -1850,41 +1884,52 @@ class Compilation extends Tapable {
 			if (deps.length === 0) continue;
 
 			// 3. Create a new Set of available modules at this points
-			newAvailableModules = new Set(availableModules);
+			newAvailableModules = new Set(minAvailableModules);
 			for (const chunk of chunkGroup.chunks) {
 				for (const m of chunk.modulesIterable) {
 					newAvailableModules.add(m);
 				}
 			}
 
-			// 4. Filter edges with available modules
-			const filteredDeps = deps.filter(filterFn);
-
-			// 5. Foreach remaining edge
+			// 4. Foreach remaining edge
 			const nextChunkGroups = new Set();
-			for (let i = 0; i < filteredDeps.length; i++) {
-				const dep = filteredDeps[i];
+			for (let i = 0; i < deps.length; i++) {
+				const dep = deps[i];
+
+				// Filter inline, rather than creating a new array from `.filter()`
+				if (!filterFn(dep)) {
+					continue;
+				}
 				const depChunkGroup = dep.chunkGroup;
 				const depBlock = dep.block;
 
-				// 6. Connect block with chunk
+				// 5. Connect block with chunk
 				GraphHelpers.connectDependenciesBlockAndChunkGroup(
 					depBlock,
 					depChunkGroup
 				);
 
-				// 7. Connect chunk with parent
+				// 6. Connect chunk with parent
 				GraphHelpers.connectChunkGroupParentAndChild(chunkGroup, depChunkGroup);
 
 				nextChunkGroups.add(depChunkGroup);
 			}
 
-			// 8. Enqueue further traversal
+			// 7. Enqueue further traversal
 			for (const nextChunkGroup of nextChunkGroups) {
-				queue2.enqueue({
-					chunkGroup: nextChunkGroup,
-					availableModules: newAvailableModules
-				});
+				let nextInfo = chunkGroupInfoMap.get(nextChunkGroup);
+				if (nextInfo === undefined) {
+					nextInfo = {
+						minAvailableModules: undefined,
+						availableModulesToBeMerged: []
+					};
+					chunkGroupInfoMap.set(nextChunkGroup, nextInfo);
+				}
+				nextInfo.availableModulesToBeMerged.push(newAvailableModules);
+
+				// As queue deduplicates enqueued items this makes sure that a ChunkGroup
+				// is not enqueued twice
+				queue2.enqueue(nextChunkGroup);
 			}
 		}
 
@@ -2113,6 +2158,8 @@ class Compilation extends Tapable {
 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
 			chunks[indexChunk].sortItems();
 		}
+
+		chunks.sort((a, b) => a.compareTo(b));
 	}
 
 	sortItemsWithChunkIds() {

package/lib/Compiler.js

@@ -128,6 +128,7 @@ class Compiler extends Tapable {
 		/** @type {string|null} */
 		this.recordsOutputPath = null;
 		this.records = {};
+		this.removedFiles = new Set();
 		/** @type {Map<string, number>} */
 		this.fileTimestamps = new Map();
 		/** @type {Map<string, number>} */
@@ -184,14 +185,19 @@ class Compiler extends Tapable {
 
 		/** @type {boolean} */
 		this.running = false;
+
+		/** @type {boolean} */
+		this.watchMode = false;
 	}
 
 	watch(watchOptions, handler) {
 		if (this.running) return handler(new ConcurrentCompilationError());
 
 		this.running = true;
+		this.watchMode = true;
 		this.fileTimestamps = new Map();
 		this.contextTimestamps = new Map();
+		this.removedFiles = new Set();
 		return new Watching(this, watchOptions, handler);
 	}
 
@@ -299,7 +305,6 @@ class Compiler extends Tapable {
 
 	emitAssets(compilation, callback) {
 		let outputPath;
-
 		const emitFiles = err => {
 			if (err) return callback(err);
 

package/lib/ConstPlugin.js

@@ -221,6 +221,91 @@ class ConstPlugin {
 							}
 						}
 					);
+					parser.hooks.expressionLogicalOperator.tap(
+						"ConstPlugin",
+						expression => {
+							if (
+								expression.operator === "&&" ||
+								expression.operator === "||"
+							) {
+								const param = parser.evaluateExpression(expression.left);
+								const bool = param.asBool();
+								if (typeof bool === "boolean") {
+									// Expressions do not hoist.
+									// It is safe to remove the dead branch.
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   falsyExpression() && false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   true && someExpression();
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   truthyExpression() || false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   false && someExpression();
+									//
+									const keepRight =
+										(expression.operator === "&&" && bool) ||
+										(expression.operator === "||" && !bool);
+
+									if (param.isBoolean() || keepRight) {
+										// for case like
+										//
+										//   return'development'===process.env.NODE_ENV&&'foo'
+										//
+										// we need a space before the bool to prevent result like
+										//
+										//   returnfalse&&'foo'
+										//
+										const dep = new ConstDependency(` ${bool}`, param.range);
+										dep.loc = expression.loc;
+										parser.state.current.addDependency(dep);
+									} else {
+										parser.walkExpression(expression.left);
+									}
+									if (!keepRight) {
+										const dep = new ConstDependency(
+											"false",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.current.addDependency(dep);
+									}
+									return keepRight;
+								}
+							}
+						}
+					);
 					parser.hooks.evaluateIdentifier
 						.for("__resourceQuery")
 						.tap("ConstPlugin", expr => {

package/lib/Entrypoint.js

@@ -49,6 +49,16 @@ class Entrypoint extends ChunkGroup {
 	getRuntimeChunk() {
 		return this.runtimeChunk || this.chunks[0];
 	}
+
+	/**
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunkt that will be replaced
+	 * @returns {boolean} rerturns true for
+	 */
+	replaceChunk(oldChunk, newChunk) {
+		if (this.runtimeChunk === oldChunk) this.runtimeChunk = newChunk;
+		return super.replaceChunk(oldChunk, newChunk);
+	}
 }
 
 module.exports = Entrypoint;

package/lib/ExternalModule.js

@@ -127,13 +127,14 @@ class ExternalModule extends Module {
 				);
 			case "global":
 				return this.getSourceForGlobalVariableExternal(
-					runtime.outputOptions.globalObject,
-					this.externalType
+					request,
+					runtime.outputOptions.globalObject
 				);
 			case "commonjs":
 			case "commonjs2":
 				return this.getSourceForCommonJsExternal(request);
 			case "amd":
+			case "amd-require":
 			case "umd":
 			case "umd2":
 				return this.getSourceForAmdOrUmdExternal(

package/lib/LibraryTemplatePlugin.js

@@ -26,7 +26,9 @@ const accessorToObjectAccess = accessor => {
  */
 const accessorAccess = (base, accessor, umdProperty, joinWith = "; ") => {
 	const normalizedAccessor =
-		typeof accessor === "object" ? accessor[umdProperty] : accessor;
+		typeof accessor === "object" && !Array.isArray(accessor)
+			? accessor[umdProperty]
+			: accessor;
 	const accessors = Array.isArray(normalizedAccessor)
 		? normalizedAccessor
 		: [normalizedAccessor];
@@ -138,15 +140,16 @@ class LibraryTemplatePlugin {
 						compilation
 					);
 					break;
-				case "amd": {
+				case "amd":
+				case "amd-require": {
 					const AmdMainTemplatePlugin = require("./AmdMainTemplatePlugin");
-					if (this.name) {
-						if (typeof this.name !== "string")
-							throw new Error("library name must be a string for amd target");
-						new AmdMainTemplatePlugin(this.name).apply(compilation);
-					} else {
-						new AmdMainTemplatePlugin().apply(compilation);
+					if (this.name && typeof this.name !== "string") {
+						throw new Error("library name must be a string for amd target");
 					}
+					new AmdMainTemplatePlugin({
+						name: this.name,
+						requireAsWrapper: this.target === "amd-require"
+					}).apply(compilation);
 					break;
 				}
 				case "umd":

package/lib/MainTemplate.js

@@ -247,6 +247,19 @@ module.exports = class MainTemplate extends Tapable {
 				);
 				buf.push(Template.indent("return Promise.all(promises);"));
 				buf.push("};");
+			} else if (
+				chunk.hasModuleInGraph(m =>
+					m.blocks.some(b => b.chunkGroup && b.chunkGroup.chunks.length > 0)
+				)
+			) {
+				// There async blocks in the graph, so we need to add an empty requireEnsure
+				// function anyway. This can happen with multiple entrypoints.
+				buf.push("// The chunk loading function for additional chunks");
+				buf.push("// Since all referenced chunks are already included");
+				buf.push("// in this file, this function is empty here.");
+				buf.push(`${this.requireFn}.e = function requireEnsure() {`);
+				buf.push(Template.indent("return Promise.resolve();"));
+				buf.push("};");
 			}
 			buf.push("");
 			buf.push("// expose the modules object (__webpack_modules__)");

package/lib/Parser.js

@@ -97,6 +97,7 @@ class Parser extends Tapable {
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
 			expressionAnyMember: new HookMap(() => new SyncBailHook(["expression"])),
 			expressionConditionalOperator: new SyncBailHook(["expression"]),
+			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			program: new SyncBailHook(["ast", "comments"])
 		};
 		const HOOK_MAP_COMPAT_CONFIG = {
@@ -1598,7 +1599,14 @@ class Parser extends Tapable {
 	}
 
 	walkLogicalExpression(expression) {
-		this.walkLeftRightExpression(expression);
+		const result = this.hooks.expressionLogicalOperator.call(expression);
+		if (result === undefined) {
+			this.walkLeftRightExpression(expression);
+		} else {
+			if (result) {
+				this.walkExpression(expression.right);
+			}
+		}
 	}
 
 	walkAssignmentExpression(expression) {

package/lib/Stats.js

@@ -17,6 +17,9 @@ const optionsOrFallback = (...args) => {
 };
 
 const compareId = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
+	}
 	if (a < b) return -1;
 	if (a > b) return 1;
 	return 0;
@@ -247,24 +250,32 @@ class Stats {
 			if (a[fieldKey] === null) return 1;
 			if (b[fieldKey] === null) return -1;
 			if (a[fieldKey] === b[fieldKey]) return 0;
+			if (typeof a[fieldKey] !== typeof b[fieldKey])
+				return typeof a[fieldKey] < typeof b[fieldKey] ? -1 : 1;
 			return a[fieldKey] < b[fieldKey] ? -1 : 1;
 		};
 
-		const sortByField = field => (a, b) => {
-			if (!field) {
-				return 0;
-			}
-
-			const fieldKey = this.normalizeFieldKey(field);
-
-			// if a field is prefixed with a "!" the sort is reversed!
-			const sortIsRegular = this.sortOrderRegular(field);
-
-			return sortByFieldAndOrder(
-				fieldKey,
-				sortIsRegular ? a : b,
-				sortIsRegular ? b : a
-			);
+		const sortByField = (field, originalArray) => {
+			const originalMap = originalArray.reduce((map, v, i) => {
+				map.set(v, i);
+				return map;
+			}, new Map());
+			return (a, b) => {
+				if (field) {
+					const fieldKey = this.normalizeFieldKey(field);
+
+					// if a field is prefixed with a "!" the sort is reversed!
+					const sortIsRegular = this.sortOrderRegular(field);
+
+					const cmp = sortByFieldAndOrder(
+						fieldKey,
+						sortIsRegular ? a : b,
+						sortIsRegular ? b : a
+					);
+					if (cmp) return cmp;
+				}
+				return originalMap.get(a) - originalMap.get(b);
+			};
 		};
 
 		const formatError = e => {
@@ -380,7 +391,7 @@ class Stats {
 		}
 		if (showAssets) {
 			const assetsByFile = {};
-			const compilationAssets = Object.keys(compilation.assets);
+			const compilationAssets = Object.keys(compilation.assets).sort();
 			obj.assetsByChunkName = {};
 			obj.assets = compilationAssets
 				.map(asset => {
@@ -421,7 +432,7 @@ class Stats {
 					}
 				}
 			}
-			obj.assets.sort(sortByField(sortAssets));
+			obj.assets.sort(sortByField(sortAssets, obj.assets));
 		}
 
 		const fnChunkGroup = groupMap => {
@@ -589,11 +600,11 @@ class Stats {
 				if (module.modules) {
 					const modules = module.modules;
 					obj.modules = modules
-						.sort(sortByField("depth"))
+						.sort(sortByField("depth", modules))
 						.filter(createModuleFilter())
 						.map(fnModule);
 					obj.filteredModules = modules.length - obj.modules.length;
-					obj.modules.sort(sortByField(sortModules));
+					obj.modules.sort(sortByField(sortModules, obj.modules));
 				}
 			}
 			if (showSource && module._source) {
@@ -639,13 +650,14 @@ class Stats {
 					childrenByOrder: childIdByOrder
 				};
 				if (showChunkModules) {
-					obj.modules = chunk
-						.getModules()
-						.sort(sortByField("depth"))
+					const modules = chunk.getModules();
+					obj.modules = modules
+						.slice()
+						.sort(sortByField("depth", modules))
 						.filter(createModuleFilter())
 						.map(fnModule);
 					obj.filteredModules = chunk.getNumberOfModules() - obj.modules.length;
-					obj.modules.sort(sortByField(sortModules));
+					obj.modules.sort(sortByField(sortModules, obj.modules));
 				}
 				if (showChunkOrigins) {
 					obj.origins = Array.from(chunk.groupsIterable, g => g.origins)
@@ -662,40 +674,27 @@ class Stats {
 							reasons: origin.reasons || []
 						}))
 						.sort((a, b) => {
-							if (
-								typeof a.moduleId === "number" &&
-								typeof b.moduleId !== "number"
-							)
-								return 1;
-							if (
-								typeof a.moduleId !== "number" &&
-								typeof b.moduleId === "number"
-							)
-								return -1;
-							if (
-								typeof a.moduleId === "number" &&
-								typeof b.moduleId === "number"
-							) {
-								const diffId = a.moduleId - b.moduleId;
-								if (diffId !== 0) return diffId;
-							}
-							if (a.loc < b.loc) return -1;
-							if (a.loc > b.loc) return 1;
+							const cmp1 = compareId(a.moduleId, b.moduleId);
+							if (cmp1) return cmp1;
+							const cmp2 = compareId(a.loc, b.loc);
+							if (cmp2) return cmp2;
+							const cmp3 = compareId(a.request, b.request);
+							if (cmp3) return cmp3;
 							return 0;
 						});
 				}
 				return obj;
 			});
-			obj.chunks.sort(sortByField(sortChunks));
+			obj.chunks.sort(sortByField(sortChunks, obj.chunks));
 		}
 		if (showModules) {
 			obj.modules = compilation.modules
 				.slice()
-				.sort(sortByField("depth"))
+				.sort(sortByField("depth", compilation.modules))
 				.filter(createModuleFilter())
 				.map(fnModule);
 			obj.filteredModules = compilation.modules.length - obj.modules.length;
-			obj.modules.sort(sortByField(sortModules));
+			obj.modules.sort(sortByField(sortModules, obj.modules));
 		}
 		if (showChildren) {
 			obj.children = compilation.children.map((child, idx) => {

package/lib/WatchIgnorePlugin.js

@@ -38,10 +38,10 @@ class IgnoringWatchFileSystem {
 				dirsModified,
 				missingModified,
 				fileTimestamps,
-				dirTimestamps
+				dirTimestamps,
+				removedFiles
 			) => {
 				if (err) return callback(err);
-
 				for (const path of ignoredFiles) {
 					fileTimestamps.set(path, 1);
 				}
@@ -56,7 +56,8 @@ class IgnoringWatchFileSystem {
 					dirsModified,
 					missingModified,
 					fileTimestamps,
-					dirTimestamps
+					dirTimestamps,
+					removedFiles
 				);
 			},
 			callbackUndelayed