webpack 5.21.0 → 5.23.0

package/lib/ChunkGraph.js

@@ -7,6 +7,7 @@
 
 const util = require("util");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const { first } = require("./util/SetHelpers");
 const SortableSet = require("./util/SortableSet");
 const StringXor = require("./util/StringXor");
 const {
@@ -1215,7 +1216,7 @@ class ChunkGraph {
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 				);
 			}
-			return hashInfoItems.values().next().value;
+			return first(hashInfoItems);
 		} else {
 			const hashInfo = hashes.get(runtime);
 			if (!hashInfo) {
@@ -1405,7 +1406,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 						true
 					);
 					if (states.size === 1) {
-						const state = states.values().next().value;
+						const state = first(states);
 						if (state === false) continue;
 						stateInfo = activeStateToString(state);
 					}

package/lib/CodeGenerationResults.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { provide } = require("./util/MapHelpers");
+const { first } = require("./util/SetHelpers");
 const createHash = require("./util/createHash");
 const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
 
@@ -47,7 +48,7 @@ class CodeGenerationResults {
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 					);
 				}
-				return results.values().next().value;
+				return first(results);
 			}
 			return entry.values().next().value;
 		}

package/lib/Compilation.js

@@ -2185,14 +2185,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				...mapAndSort(includeDependencies)
 			];
 
+			let modulesList = chunkGraphInit.get(entrypoint);
+			if (modulesList === undefined) {
+				chunkGraphInit.set(entrypoint, (modulesList = []));
+			}
 			for (const module of includedModules) {
 				this.assignDepth(module);
-				const modulesList = chunkGraphInit.get(entrypoint);
-				if (modulesList === undefined) {
-					chunkGraphInit.set(entrypoint, [module]);
-				} else {
-					modulesList.push(module);
-				}
+				modulesList.push(module);
 			}
 		}
 		const runtimeChunks = new Set();
@@ -3136,54 +3135,106 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 
 		this.logger.time("hashing: sort chunks");
-		// clone needed as sort below is in place mutation
-		const chunks = Array.from(this.chunks);
-		/**
-		 * sort here will bring all "falsy" values to the beginning
-		 * this is needed as the "hasRuntime()" chunks are dependent on the
-		 * hashes of the non-runtime chunks.
+		/*
+		 * all non-runtime chunks need to be hashes first,
+		 * since runtime chunk might use their hashes.
+		 * runtime chunks need to be hashed in the correct order
+		 * since they may depend on each other (for async entrypoints).
+		 * So we put all non-runtime chunks first and hash them in any order.
+		 * And order runtime chunks according to referenced between each other.
+		 * Chunks need to be in deterministic order since we add hashes to full chunk
+		 * during these hashing.
 		 */
-		const runtimeChunks = [];
+		/** @type {Chunk[]} */
+		const unorderedRuntimeChunks = [];
+		/** @type {Chunk[]} */
 		const otherChunks = [];
-		for (const c of chunks) {
+		for (const c of this.chunks) {
 			if (c.hasRuntime()) {
-				runtimeChunks.push({
-					chunk: c,
-					referencedChunks: new Set(
-						Array.from(c.getAllReferencedAsyncEntrypoints()).map(
-							e => e.chunks[e.chunks.length - 1]
-						)
-					)
-				});
+				unorderedRuntimeChunks.push(c);
 			} else {
 				otherChunks.push(c);
 			}
 		}
+		unorderedRuntimeChunks.sort(byId);
 		otherChunks.sort(byId);
-		runtimeChunks.sort((a, b) => {
-			const aDependOnB = a.referencedChunks.has(b.chunk);
-			const bDependOnA = b.referencedChunks.has(a.chunk);
-			if (aDependOnB && bDependOnA) {
-				const err = new WebpackError(
-					`Circular dependency between chunks with runtime (${
-						a.chunk.name || a.chunk.id
-					} and ${b.chunk.name || b.chunk.id}).
-This prevents using hashes of each other and should be avoided.`
-				);
-				err.chunk = a.chunk;
-				this.warnings.push(err);
-				return byId(a.chunk, b.chunk);
+
+		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
+		/** @type {Map<Chunk, RuntimeChunkInfo>} */
+		const runtimeChunksMap = new Map();
+		for (const chunk of unorderedRuntimeChunks) {
+			runtimeChunksMap.set(chunk, {
+				chunk,
+				referencedBy: [],
+				remaining: 0
+			});
+		}
+		let remaining = 0;
+		for (const info of runtimeChunksMap.values()) {
+			for (const other of new Set(
+				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
+					e => e.chunks[e.chunks.length - 1]
+				)
+			)) {
+				const otherInfo = runtimeChunksMap.get(other);
+				otherInfo.referencedBy.push(info);
+				info.remaining++;
+				remaining++;
 			}
-			if (aDependOnB) return 1;
-			if (bDependOnA) return -1;
-			return byId(a.chunk, b.chunk);
-		});
+		}
+		/** @type {Chunk[]} */
+		const runtimeChunks = [];
+		for (const info of runtimeChunksMap.values()) {
+			if (info.remaining === 0) {
+				runtimeChunks.push(info.chunk);
+			}
+		}
+		// If there are any references between chunks
+		// make sure to follow these chains
+		if (remaining > 0) {
+			const readyChunks = [];
+			for (const chunk of runtimeChunks) {
+				const info = runtimeChunksMap.get(chunk);
+				for (const otherInfo of info.referencedBy) {
+					remaining--;
+					if (--otherInfo.remaining === 0) {
+						readyChunks.push(otherInfo.chunk);
+					}
+				}
+				if (readyChunks.length > 0) {
+					// This ensures deterministic ordering, since referencedBy is non-deterministic
+					readyChunks.sort(byId);
+					for (const c of readyChunks) runtimeChunks.push(c);
+					readyChunks.length = 0;
+				}
+			}
+		}
+		// If there are still remaining references we have cycles and want to create a warning
+		if (remaining > 0) {
+			let circularRuntimeChunkInfo = [];
+			for (const info of runtimeChunksMap.values()) {
+				if (info.remaining !== 0) {
+					circularRuntimeChunkInfo.push(info);
+				}
+			}
+			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
+			const err = new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
+				circularRuntimeChunkInfo,
+				c => c.chunk.name || c.chunk.id
+			).join(", ")})
+This prevents using hashes of each other and should be avoided.`);
+			err.chunk = circularRuntimeChunkInfo[0].chunk;
+			this.warnings.push(err);
+			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+		}
 		this.logger.timeEnd("hashing: sort chunks");
+
 		const fullHashChunks = new Set();
 		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
 		const codeGenerationJobs = [];
 		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
 		const codeGenerationJobsMap = new Map();
+
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
@@ -3253,7 +3304,7 @@ This prevents using hashes of each other and should be avoided.`
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
 		otherChunks.forEach(processChunk);
-		for (const { chunk } of runtimeChunks) processChunk(chunk);
+		for (const chunk of runtimeChunks) processChunk(chunk);
 
 		this.logger.timeAggregateEnd("hashing: hash runtime modules");
 		this.logger.timeAggregateEnd("hashing: hash chunks");

package/lib/EvalDevToolModulePlugin.js

@@ -82,6 +82,10 @@ class EvalDevToolModulePlugin {
 					return result;
 				}
 			);
+			hooks.inlineInRuntimeBailout.tap(
+				"EvalDevToolModulePlugin",
+				() => "the eval devtool is used."
+			);
 			hooks.render.tap(
 				"EvalDevToolModulePlugin",
 				source => new ConcatSource(devtoolWarning, source)

package/lib/EvalSourceMapDevToolPlugin.js

@@ -166,6 +166,10 @@ class EvalSourceMapDevToolPlugin {
 						);
 					}
 				);
+				hooks.inlineInRuntimeBailout.tap(
+					"EvalDevToolModulePlugin",
+					() => "the eval-source-map devtool is used."
+				);
 				hooks.render.tap(
 					"EvalSourceMapDevToolPlugin",
 					source => new ConcatSource(devtoolWarning, source)

package/lib/ExportsInfo.js

@@ -395,6 +395,7 @@ class ExportsInfo {
 	setAllKnownExportsUsed(runtime) {
 		let changed = false;
 		for (const exportInfo of this._exports.values()) {
+			if (!exportInfo.provided) continue;
 			if (exportInfo.setUsed(UsageState.Used, runtime)) {
 				changed = true;
 			}

package/lib/ExternalModule.js

@@ -124,7 +124,7 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 	const url = urlAndGlobal[0];
 	const globalName = urlAndGlobal[1];
 	return {
-		init: "var error = new Error();",
+		init: "var __webpack_error__ = new Error();",
 		expression: `new Promise(${runtimeTemplate.basicFunction(
 			"resolve, reject",
 			[
@@ -135,11 +135,11 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 					`if(typeof ${globalName} !== "undefined") return resolve();`,
 					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
 					"var realSrc = event && event.target && event.target.src;",
-					"error.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
-					"error.name = 'ScriptExternalLoadError';",
-					"error.type = errorType;",
-					"error.request = realSrc;",
-					"reject(error);"
+					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
+					"__webpack_error__.name = 'ScriptExternalLoadError';",
+					"__webpack_error__.type = errorType;",
+					"__webpack_error__.request = realSrc;",
+					"reject(__webpack_error__);"
 				])}, ${JSON.stringify(globalName)});`
 			]
 		)}).then(${runtimeTemplate.returningFunction(
@@ -293,7 +293,8 @@ class ExternalModule extends Module {
 			exportsType: undefined
 		};
 		this.buildInfo = {
-			strict: this.externalType !== "this"
+			strict: this.externalType !== "this",
+			topLevelDeclarations: new Set()
 		};
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;

package/lib/FlagDependencyUsagePlugin.js

@@ -161,9 +161,10 @@ class FlagDependencyUsagePlugin {
 					/**
 					 * @param {DependenciesBlock} module the module
 					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processModule = (module, runtime) => {
+					const processModule = (module, runtime, forceSideEffects) => {
 						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
 						const map = new Map();
 
@@ -179,7 +180,7 @@ class FlagDependencyUsagePlugin {
 									b.groupOptions &&
 									b.groupOptions.entryOptions
 								) {
-									processModule(b, b.groupOptions.entryOptions.runtime);
+									processModule(b, b.groupOptions.entryOptions.runtime, true);
 								} else {
 									queue.enqueue(b);
 								}
@@ -193,7 +194,7 @@ class FlagDependencyUsagePlugin {
 								if (activeState === false) continue;
 								const { module } = connection;
 								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-									processModule(module, runtime);
+									processModule(module, runtime, false);
 									continue;
 								}
 								const oldReferencedExports = map.get(module);
@@ -263,14 +264,14 @@ class FlagDependencyUsagePlugin {
 									module,
 									referencedExports,
 									runtime,
-									false
+									forceSideEffects
 								);
 							} else {
 								processReferencedModule(
 									module,
 									Array.from(referencedExports.values()),
 									runtime,
-									false
+									forceSideEffects
 								);
 							}
 						}
@@ -327,7 +328,7 @@ class FlagDependencyUsagePlugin {
 
 					while (queue.length) {
 						const [module, runtime] = queue.dequeue();
-						processModule(module, runtime);
+						processModule(module, runtime, false);
 					}
 					logger.timeEnd("trace exports usage in graph");
 				}

package/lib/JavascriptMetaInfoPlugin.js

@@ -0,0 +1,62 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const InnerGraph = require("./optimize/InnerGraph");
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class JavascriptMetaInfoPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JavascriptMetaInfoPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
+						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
+						parser.state.module.buildInfo.usingEval = true;
+						InnerGraph.bailout(parser.state);
+					});
+					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
+						let topLevelDeclarations =
+							parser.state.module.buildInfo.topLevelDeclarations;
+						if (topLevelDeclarations === undefined) {
+							topLevelDeclarations = parser.state.module.buildInfo.topLevelDeclarations = new Set();
+						}
+						for (const name of parser.scope.definitions.asSet()) {
+							const freeInfo = parser.getFreeInfoFromVariable(name);
+							if (freeInfo === undefined) {
+								topLevelDeclarations.add(name);
+							}
+						}
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("JavascriptMetaInfoPlugin", handler);
+			}
+		);
+	}
+}
+
+module.exports = JavascriptMetaInfoPlugin;

package/lib/LibManifestPlugin.js

@@ -7,6 +7,7 @@
 
 const asyncLib = require("neo-async");
 const EntryDependency = require("./dependencies/EntryDependency");
+const { someInIterable } = require("./util/IterableHelpers");
 const { compareModulesById } = require("./util/comparators");
 const { dirname, mkdirp } = require("./util/fs");
 
@@ -19,19 +20,6 @@ const { dirname, mkdirp } = require("./util/fs");
  * @property {boolean | string[]} exports
  */
 
-/**
- * @template T
- * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean} filter predicate
- * @returns {boolean} true, if some items match the filter predicate
- */
-const someInIterable = (iterable, filter) => {
-	for (const item of iterable) {
-		if (filter(item)) return true;
-	}
-	return false;
-};
-
 class LibManifestPlugin {
 	constructor(options) {
 		this.options = options;

package/lib/Module.js

@@ -10,6 +10,7 @@ const ChunkGraph = require("./ChunkGraph");
 const DependenciesBlock = require("./DependenciesBlock");
 const ModuleGraph = require("./ModuleGraph");
 const RuntimeGlobals = require("./RuntimeGlobals");
+const { first } = require("./util/SetHelpers");
 const { compareChunksById } = require("./util/comparators");
 const makeSerializable = require("./util/makeSerializable");
 
@@ -796,9 +797,7 @@ class Module extends DependenciesBlock {
 			runtime: undefined
 		};
 		const sources = this.codeGeneration(codeGenContext).sources;
-		return type
-			? sources.get(type)
-			: sources.get(this.getSourceTypes().values().next().value);
+		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
 	}
 
 	/* istanbul ignore next */