webpack 5.59.0 → 5.94.0

package/lib/optimize/LimitChunkCountPlugin.js

@@ -24,7 +24,7 @@ const validate = createSchemaValidation(
 );
 
 /**
- * @typedef {Object} ChunkCombination
+ * @typedef {object} ChunkCombination
  * @property {boolean} deleted this is set to true when combination was removed
  * @property {number} sizeDiff
  * @property {number} integratedSize
@@ -36,6 +36,12 @@ const validate = createSchemaValidation(
  * @property {number} bSize
  */
 
+/**
+ * @template K, V
+ * @param {Map<K, Set<V>>} map map
+ * @param {K} key key
+ * @param {V} value value
+ */
 const addToSetMap = (map, key, value) => {
 	const set = map.get(key);
 	if (set === undefined) {
@@ -68,7 +74,9 @@ class LimitChunkCountPlugin {
 				},
 				chunks => {
 					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
+					const maxChunks =
+						/** @type {LimitChunkCountPluginOptions} */
+						(options).maxChunks;
 					if (!maxChunks) return;
 					if (maxChunks < 1) return;
 					if (compilation.chunks.size <= maxChunks) return;
@@ -88,9 +96,17 @@ class LimitChunkCountPlugin {
 						c => c.sizeDiff,
 						(a, b) => b - a,
 						// Layer 2: ordered by smallest combined size
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} integrated size
+						 */
 						c => c.integratedSize,
 						(a, b) => a - b,
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} position difference
+						 */
 						c => c.bIdx - c.aIdx,
 						(a, b) => a - b,
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
@@ -103,7 +119,7 @@ class LimitChunkCountPlugin {
 					/** @type {Map<Chunk, Set<ChunkCombination>>} */
 					const combinationsByChunk = new Map();
 
-					orderedChunks.forEach((b, bIdx) => {
+					for (const [bIdx, b] of orderedChunks.entries()) {
 						// create combination pairs with size and integrated size
 						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
 							const a = orderedChunks[aIdx];
@@ -133,8 +149,7 @@ class LimitChunkCountPlugin {
 							addToSetMap(combinationsByChunk, a, c);
 							addToSetMap(combinationsByChunk, b, c);
 						}
-						return combinations;
-					});
+					}
 
 					// list of modified chunks during this run
 					// combinations affected by this change are skipped to allow
@@ -143,7 +158,6 @@ class LimitChunkCountPlugin {
 					const modifiedChunks = new Set();
 
 					let changed = false;
-					// eslint-disable-next-line no-constant-condition
 					loop: while (true) {
 						const combination = combinations.popFirst();
 						if (combination === undefined) break;
@@ -193,14 +207,18 @@ class LimitChunkCountPlugin {
 							// Update all affected combinations
 							// delete all combination with the removed chunk
 							// we will use combinations with the kept chunk instead
-							for (const combination of combinationsByChunk.get(a)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(a)
+							)) {
 								if (combination.deleted) continue;
 								combination.deleted = true;
 								combinations.delete(combination);
 							}
 
 							// Update combinations with the kept chunk with new sizes
-							for (const combination of combinationsByChunk.get(b)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(b)
+							)) {
 								if (combination.deleted) continue;
 								if (combination.a === b) {
 									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
@@ -243,7 +261,12 @@ class LimitChunkCountPlugin {
 									finishUpdate();
 								}
 							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
+							combinationsByChunk.set(
+								a,
+								/** @type {Set<ChunkCombination>} */ (
+									combinationsByChunk.get(b)
+								)
+							);
 							combinationsByChunk.delete(b);
 						}
 					}

package/lib/optimize/MangleExportsPlugin.js

@@ -39,7 +39,7 @@ const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
- * @param {boolean} isNamespace is namespace object
+ * @param {boolean | undefined} isNamespace is namespace object
  * @returns {void}
  */
 const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
@@ -88,7 +88,11 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 				used === UsageState.OnlyPropertiesUsed ||
 				used === UsageState.Unused
 			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
+				mangleExportsInfo(
+					deterministic,
+					/** @type {ExportsInfo} */ (exportInfo.exportsInfo),
+					false
+				);
 			}
 		}
 	}
@@ -145,6 +149,7 @@ class MangleExportsPlugin {
 	constructor(deterministic) {
 		this._deterministic = deterministic;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/optimize/MinMaxSizeWarning.js

@@ -9,6 +9,11 @@ const SizeFormatHelpers = require("../SizeFormatHelpers");
 const WebpackError = require("../WebpackError");
 
 class MinMaxSizeWarning extends WebpackError {
+	/**
+	 * @param {string[] | undefined} keys keys
+	 * @param {number} minSize minimum size
+	 * @param {number} maxSize maximum size
+	 */
 	constructor(keys, minSize, maxSize) {
 		let keysMessage = "Fallback cache group";
 		if (keys) {
@@ -18,7 +23,7 @@ class MinMaxSizeWarning extends WebpackError {
 					: `Cache group ${keys[0]}`;
 		}
 		super(
-			`SplitChunksPlugin\n` +
+			"SplitChunksPlugin\n" +
 				`${keysMessage}\n` +
 				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
 				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -23,11 +23,12 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} Statistics
+ * @typedef {object} Statistics
  * @property {number} cached
  * @property {number} alreadyInConfig
  * @property {number} invalidModule
@@ -40,26 +41,34 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  * @property {number} added
  */
 
-const formatBailoutReason = msg => {
-	return "ModuleConcatenation bailout: " + msg;
-};
+/**
+ * @param {string} msg message
+ * @returns {string} formatted message
+ */
+const formatBailoutReason = msg => `ModuleConcatenation bailout: ${msg}`;
 
 class ModuleConcatenationPlugin {
-	constructor(options) {
-		if (typeof options !== "object") options = {};
-		this.options = options;
-	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
 		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+			if (compilation.moduleMemCaches) {
+				throw new Error(
+					"optimization.concatenateModules can't be used with cacheUnaffected as module concatenation is a global effect"
+				);
+			}
 			const moduleGraph = compilation.moduleGraph;
+			/** @type {Map<Module, string | ((requestShortener: RequestShortener) => string)>} */
 			const bailoutReasonMap = new Map();
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setBailoutReason = (module, reason) => {
 				setInnerBailoutReason(module, reason);
 				moduleGraph
@@ -71,16 +80,30 @@ class ModuleConcatenationPlugin {
 					);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setInnerBailoutReason = (module, reason) => {
 				bailoutReasonMap.set(module, reason);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {RequestShortener} requestShortener the request shortener
+			 * @returns {string | ((requestShortener: RequestShortener) => string) | undefined} the reason
+			 */
 			const getInnerBailoutReason = (module, requestShortener) => {
 				const reason = bailoutReasonMap.get(module);
 				if (typeof reason === "function") return reason(requestShortener);
 				return reason;
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {Module | function(RequestShortener): string} problem the problem
+			 * @returns {(requestShortener: RequestShortener) => string} the reason
+			 */
 			const formatBailoutWarning = (module, problem) => requestShortener => {
 				if (typeof problem === "function") {
 					return formatBailoutReason(
@@ -97,15 +120,14 @@ class ModuleConcatenationPlugin {
 							requestShortener
 						)}${reasonWithPrefix}`
 					);
-				} else {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)} because of ${problem.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
 				}
+				return formatBailoutReason(
+					`Cannot concat with ${module.readableIdentifier(
+						requestShortener
+					)} because of ${problem.readableIdentifier(
+						requestShortener
+					)}${reasonWithPrefix}`
+				);
 			};
 
 			compilation.hooks.optimizeChunkModules.tapAsync(
@@ -137,13 +159,13 @@ class ModuleConcatenationPlugin {
 
 						// Must not be an async module
 						if (moduleGraph.isAsync(module)) {
-							setBailoutReason(module, `Module is async`);
+							setBailoutReason(module, "Module is async");
 							continue;
 						}
 
 						// Must be in strict mode
-						if (!module.buildInfo.strict) {
-							setBailoutReason(module, `Module is not in strict mode`);
+						if (!(/** @type {BuildInfo} */ (module.buildInfo).strict)) {
+							setBailoutReason(module, "Module is not in strict mode");
 							continue;
 						}
 
@@ -156,11 +178,10 @@ class ModuleConcatenationPlugin {
 						// Exports must be known (and not dynamic)
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						const relevantExports = exportsInfo.getRelevantExports(undefined);
-						const unknownReexports = relevantExports.filter(exportInfo => {
-							return (
+						const unknownReexports = relevantExports.filter(
+							exportInfo =>
 								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
-							);
-						});
+						);
 						if (unknownReexports.length > 0) {
 							setBailoutReason(
 								module,
@@ -177,9 +198,7 @@ class ModuleConcatenationPlugin {
 
 						// Root modules must have a static list of exports
 						const unknownProvidedExports = relevantExports.filter(
-							exportInfo => {
-								return exportInfo.provided !== true;
-							}
+							exportInfo => exportInfo.provided !== true
 						);
 						if (unknownProvidedExports.length > 0) {
 							setBailoutReason(
@@ -212,9 +231,11 @@ class ModuleConcatenationPlugin {
 					// modules with lower depth are more likely suited as roots
 					// this improves performance, because modules already selected as inner are skipped
 					logger.time("sort relevant modules");
-					relevantModules.sort((a, b) => {
-						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
-					});
+					relevantModules.sort(
+						(a, b) =>
+							/** @type {number} */ (moduleGraph.getDepth(a)) -
+							/** @type {number} */ (moduleGraph.getDepth(b))
+					);
 					logger.timeEnd("sort relevant modules");
 
 					/** @type {Statistics} */
@@ -243,7 +264,7 @@ class ModuleConcatenationPlugin {
 						// TODO reconsider that when it's only used in a different runtime
 						if (usedAsInner.has(currentRoot)) continue;
 
-						let chunkRuntime = undefined;
+						let chunkRuntime;
 						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
 							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
 						}
@@ -255,8 +276,8 @@ class ModuleConcatenationPlugin {
 							filteredRuntime === true
 								? chunkRuntime
 								: filteredRuntime === false
-								? undefined
-								: filteredRuntime;
+									? undefined
+									: filteredRuntime;
 
 						// create a configuration with the root
 						const currentConfiguration = new ConcatConfiguration(
@@ -340,11 +361,9 @@ class ModuleConcatenationPlugin {
 					// to get the biggest groups possible. Used modules are marked with usedModules
 					// TODO: Allow to reuse existing configuration while trying to add dependencies.
 					// This would improve performance. O(n^2) -> O(n)
-					logger.time(`sort concat configurations`);
-					concatConfigurations.sort((a, b) => {
-						return b.modules.size - a.modules.size;
-					});
-					logger.timeEnd(`sort concat configurations`);
+					logger.time("sort concat configurations");
+					concatConfigurations.sort((a, b) => b.modules.size - a.modules.size);
+					logger.timeEnd("sort concat configurations");
 					const usedModules = new Set();
 
 					logger.time("create concatenated modules");
@@ -362,10 +381,12 @@ class ModuleConcatenationPlugin {
 							}
 
 							// Create a new ConcatenatedModule
-							let newModule = ConcatenatedModule.create(
+							ConcatenatedModule.getCompilationHooks(compilation);
+							const newModule = ConcatenatedModule.create(
 								rootModule,
 								modules,
 								concatConfiguration.runtime,
+								compilation,
 								compiler.root,
 								compilation.outputOptions.hashFunction
 							);
@@ -389,8 +410,10 @@ class ModuleConcatenationPlugin {
 							};
 
 							const integrate = () => {
-								ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
-								ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
+								if (backCompat) {
+									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
+									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
+								}
 
 								for (const warning of concatConfiguration.getWarningsSorted()) {
 									moduleGraph
@@ -408,21 +431,32 @@ class ModuleConcatenationPlugin {
 										moduleGraph.copyOutgoingModuleConnections(
 											m,
 											newModule,
-											c => {
-												return (
-													c.originModule === m &&
-													!(
-														c.dependency instanceof HarmonyImportDependency &&
-														modules.has(c.module)
-													)
-												);
-											}
+											c =>
+												c.originModule === m &&
+												!(
+													c.dependency instanceof HarmonyImportDependency &&
+													modules.has(c.module)
+												)
 										);
 										// remove module from chunk
 										for (const chunk of chunkGraph.getModuleChunksIterable(
 											rootModule
 										)) {
-											chunkGraph.disconnectChunkAndModule(chunk, m);
+											const sourceTypes = chunkGraph.getChunkModuleSourceTypes(
+												chunk,
+												m
+											);
+											if (sourceTypes.size === 1) {
+												chunkGraph.disconnectChunkAndModule(chunk, m);
+											} else {
+												const newSourceTypes = new Set(sourceTypes);
+												newSourceTypes.delete("javascript");
+												chunkGraph.setChunkModuleSourceTypes(
+													chunk,
+													m,
+													newSourceTypes
+												);
+											}
 										}
 									}
 								}
@@ -438,7 +472,7 @@ class ModuleConcatenationPlugin {
 										c.module === rootModule ? c.originModule : c.module;
 									const innerConnection =
 										c.dependency instanceof HarmonyImportDependency &&
-										modules.has(otherModule);
+										modules.has(/** @type {Module} */ (otherModule));
 									return !innerConnection;
 								});
 								// add concatenated module to the compilation
@@ -511,7 +545,7 @@ class ModuleConcatenationPlugin {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
 	 * @param {Statistics} statistics gathering metrics
-	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 * @returns {null | Module | function(RequestShortener): string} the problematic module
 	 */
 	_tryToAdd(
 		compilation,
@@ -550,6 +584,10 @@ class ModuleConcatenationPlugin {
 			chunkGraph.getModuleChunksIterable(config.rootModule)
 		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const missingChunksList = Array.from(
 					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
@@ -581,12 +619,16 @@ class ModuleConcatenationPlugin {
 			incomingConnections.get(null) || incomingConnections.get(undefined);
 		if (incomingConnectionsFromNonModules) {
 			const activeNonModulesConnections =
-				incomingConnectionsFromNonModules.filter(connection => {
+				incomingConnectionsFromNonModules.filter(connection =>
 					// We are not interested in inactive connections
 					// or connections without dependency
-					return connection.isActive(runtime) || connection.dependency;
-				});
+					connection.isActive(runtime)
+				);
 			if (activeNonModulesConnections.length > 0) {
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
 				const problem = requestShortener => {
 					const importingExplanations = new Set(
 						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
@@ -614,7 +656,7 @@ class ModuleConcatenationPlugin {
 				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
 				// We don't care for connections from other runtimes
-				let originRuntime = undefined;
+				let originRuntime;
 				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
 					originRuntime = mergeRuntimeOwned(originRuntime, r);
 				}
@@ -644,6 +686,10 @@ class ModuleConcatenationPlugin {
 			return false;
 		});
 		if (otherChunkModules.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = otherChunkModules
 					.map(m => m.readableIdentifier(requestShortener))
@@ -671,21 +717,26 @@ class ModuleConcatenationPlugin {
 				nonHarmonyConnections.set(originModule, connections);
 		}
 		if (nonHarmonyConnections.size > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = Array.from(nonHarmonyConnections)
-					.map(([originModule, connections]) => {
-						return `${originModule.readableIdentifier(
-							requestShortener
-						)} (referenced with ${Array.from(
-							new Set(
-								connections
-									.map(c => c.dependency && c.dependency.type)
-									.filter(Boolean)
+					.map(
+						([originModule, connections]) =>
+							`${originModule.readableIdentifier(
+								requestShortener
+							)} (referenced with ${Array.from(
+								new Set(
+									connections
+										.map(c => c.dependency && c.dependency.type)
+										.filter(Boolean)
+								)
 							)
-						)
-							.sort()
-							.join(", ")})`;
-					})
+								.sort()
+								.join(", ")})`
+					)
 					.sort();
 				return `Module ${module.readableIdentifier(
 					requestShortener
@@ -709,19 +760,15 @@ class ModuleConcatenationPlugin {
 				/** @type {false | RuntimeSpec} */
 				let currentRuntimeCondition = false;
 				for (const connection of connections) {
-					const runtimeCondition = filterRuntime(runtime, runtime => {
-						return connection.isTargetActive(runtime);
-					});
+					const runtimeCondition = filterRuntime(runtime, runtime =>
+						connection.isTargetActive(runtime)
+					);
 					if (runtimeCondition === false) continue;
 					if (runtimeCondition === true) continue outer;
-					if (currentRuntimeCondition !== false) {
-						currentRuntimeCondition = mergeRuntime(
-							currentRuntimeCondition,
-							runtimeCondition
-						);
-					} else {
-						currentRuntimeCondition = runtimeCondition;
-					}
+					currentRuntimeCondition =
+						currentRuntimeCondition !== false
+							? mergeRuntime(currentRuntimeCondition, runtimeCondition)
+							: runtimeCondition;
 				}
 				if (currentRuntimeCondition !== false) {
 					otherRuntimeConnections.push({
@@ -731,8 +778,12 @@ class ModuleConcatenationPlugin {
 				}
 			}
 			if (otherRuntimeConnections.length > 0) {
-				const problem = requestShortener => {
-					return `Module ${module.readableIdentifier(
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
+				const problem = requestShortener =>
+					`Module ${module.readableIdentifier(
 						requestShortener
 					)} is runtime-dependent referenced by these modules: ${Array.from(
 						otherRuntimeConnections,
@@ -745,7 +796,6 @@ class ModuleConcatenationPlugin {
 								/** @type {RuntimeSpec} */ (runtimeCondition)
 							)})`
 					).join(", ")}`;
-				};
 				statistics.incorrectRuntimeCondition++;
 				failureCache.set(module, problem); // cache failures for performance
 				return problem;
@@ -809,10 +859,17 @@ class ConcatConfiguration {
 		this.warnings = new Map();
 	}
 
+	/**
+	 * @param {Module} module the module
+	 */
 	add(module) {
 		this.modules.add(module);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, when the module is in the module set
+	 */
 	has(module) {
 		return this.modules.has(module);
 	}
@@ -821,10 +878,17 @@ class ConcatConfiguration {
 		return this.modules.size === 1;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | function(RequestShortener): string} problem the problem
+	 */
 	addWarning(module, problem) {
 		this.warnings.set(module, problem);
 	}
 
+	/**
+	 * @returns {Map<Module, Module | function(RequestShortener): string>} warnings
+	 */
 	getWarningsSorted() {
 		return new Map(
 			Array.from(this.warnings).sort((a, b) => {
@@ -848,6 +912,9 @@ class ConcatConfiguration {
 		return this.modules.size;
 	}
 
+	/**
+	 * @param {number} snapshot snapshot
+	 */
 	rollback(snapshot) {
 		const modules = this.modules;
 		for (const m of modules) {