webpack 5.58.0 → 5.59.1

package/lib/ChunkGraph.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const util = require("util");
-const ChunkCombination = require("./ChunkCombination");
 const Entrypoint = require("./Entrypoint");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { first } = require("./util/SetHelpers");
@@ -41,8 +40,6 @@ const {
 /** @type {ReadonlySet<string>} */
 const EMPTY_SET = new Set();
 
-const EMPTY_RUNTIME_SPEC_SET = new RuntimeSpecSet();
-
 const ZERO_BIG_INT = BigInt(0);
 
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
@@ -180,7 +177,8 @@ const isAvailableChunk = (a, b) => {
 
 class ChunkGraphModule {
 	constructor() {
-		this.chunkCombination = ChunkCombination.empty;
+		/** @type {SortableSet<Chunk>} */
+		this.chunks = new SortableSet();
 		/** @type {Set<Chunk> | undefined} */
 		this.entryInChunks = undefined;
 		/** @type {Set<Chunk> | undefined} */
@@ -303,7 +301,7 @@ class ChunkGraph {
 	connectChunkAndModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.chunkCombination = cgm.chunkCombination.with(chunk);
+		cgm.chunks.add(chunk);
 		cgc.modules.add(module);
 	}
 
@@ -316,7 +314,7 @@ class ChunkGraph {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
 		cgc.modules.delete(module);
-		cgm.chunkCombination = cgm.chunkCombination.without(chunk);
+		cgm.chunks.delete(chunk);
 	}
 
 	/**
@@ -327,7 +325,7 @@ class ChunkGraph {
 		const cgc = this._getChunkGraphChunk(chunk);
 		for (const module of cgc.modules) {
 			const cgm = this._getChunkGraphModule(module);
-			cgm.chunkCombination = cgm.chunkCombination.without(chunk);
+			cgm.chunks.delete(chunk);
 		}
 		cgc.modules.clear();
 		chunk.disconnectFromGroups();
@@ -394,13 +392,13 @@ class ChunkGraph {
 		const oldCgm = this._getChunkGraphModule(oldModule);
 		const newCgm = this._getChunkGraphModule(newModule);
 
-		for (const chunk of oldCgm.chunkCombination._chunks) {
+		for (const chunk of oldCgm.chunks) {
 			const cgc = this._getChunkGraphChunk(chunk);
 			cgc.modules.delete(oldModule);
 			cgc.modules.add(newModule);
-			newCgm.chunkCombination = newCgm.chunkCombination.with(chunk);
+			newCgm.chunks.add(chunk);
 		}
-		oldCgm.chunkCombination = ChunkCombination.empty;
+		oldCgm.chunks.clear();
 
 		if (oldCgm.entryInChunks !== undefined) {
 			if (newCgm.entryInChunks === undefined) {
@@ -487,22 +485,13 @@ class ChunkGraph {
 		return cgm.entryInChunks !== undefined;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {ChunkCombination} chunk combination (do not modify)
-	 */
-	getModuleChunkCombination(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunkCombination;
-	}
-
 	/**
 	 * @param {Module} module the module
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getModuleChunksIterable(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunkCombination._chunks;
+		return cgm.chunks;
 	}
 
 	/**
@@ -512,9 +501,8 @@ class ChunkGraph {
 	 */
 	getOrderedModuleChunksIterable(module, sortFn) {
 		const cgm = this._getChunkGraphModule(module);
-		const chunks = cgm.chunkCombination._chunks;
-		chunks.sortWith(sortFn);
-		return chunks;
+		cgm.chunks.sortWith(sortFn);
+		return cgm.chunks;
 	}
 
 	/**
@@ -523,7 +511,7 @@ class ChunkGraph {
 	 */
 	getModuleChunks(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunkCombination.getChunks();
+		return cgm.chunks.getFromCache(getArray);
 	}
 
 	/**
@@ -532,7 +520,7 @@ class ChunkGraph {
 	 */
 	getNumberOfModuleChunks(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunkCombination.size;
+		return cgm.chunks.size;
 	}
 
 	/**
@@ -541,10 +529,7 @@ class ChunkGraph {
 	 */
 	getModuleRuntimes(module) {
 		const cgm = this._getChunkGraphModule(module);
-		if (cgm.chunkCombination.size === 0) return EMPTY_RUNTIME_SPEC_SET;
-		return cgm.chunkCombination._chunks.getFromUnorderedCache(
-			getModuleRuntimes
-		);
+		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
 	}
 
 	/**
@@ -908,7 +893,8 @@ class ChunkGraph {
 		// Merge runtime
 		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
 
-		for (const module of this.getChunkModulesIterable(chunkB)) {
+		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
+		for (const module of this.getChunkModules(chunkB)) {
 			this.disconnectChunkAndModule(chunkB, module);
 			this.connectChunkAndModule(chunkA, module);
 		}

package/lib/Compilation.js

@@ -416,10 +416,10 @@ const byLocation = compareSelect(err => err.loc, compareLocations);
 
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function }>} */
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
 const unsafeCacheDependencies = new WeakMap();
 
-/** @type {WeakMap<Module, object>} */
+/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
 const unsafeCacheData = new WeakMap();
 
 class Compilation {
@@ -1023,8 +1023,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.usedModuleIds = null;
 		/** @type {boolean} */
 		this.needAdditionalPass = false;
-		/** @type {Set<Module>} */
-		this._restoredUnsafeCacheEntries = new Set();
+		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheModuleEntries = new Set();
+		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheEntries = new Map();
 		/** @type {WeakSet<Module>} */
 		this.builtModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
@@ -1424,9 +1426,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/**
-		 * @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>}
-		 */
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
 		const sortedDependencies = [];
 
 		/** @type {DependenciesBlock} */
@@ -1447,7 +1447,46 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {Dependency[]} */
 		let listCacheValue;
 
-		const unsafeRestoredModules = new Set();
+		let inProgressSorting = 1;
+		let inProgressTransitive = 1;
+
+		const onDependenciesSorted = err => {
+			if (err) return callback(err);
+
+			// early exit without changing parallelism back and forth
+			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
+				return callback();
+			}
+
+			// This is nested so we need to allow one additional task
+			this.processDependenciesQueue.increaseParallelism();
+
+			for (const item of sortedDependencies) {
+				inProgressTransitive++;
+				this.handleModuleCreation(item, err => {
+					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
+					// errors are created inside closures that keep a reference to the Compilation, so errors are
+					// leaking the Compilation object.
+					if (err && this.bail) {
+						if (inProgressTransitive <= 0) return;
+						inProgressTransitive = -1;
+						// eslint-disable-next-line no-self-assign
+						err.stack = err.stack;
+						onTransitiveTasksFinished(err);
+						return;
+					}
+					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+				});
+			}
+			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+		};
+
+		const onTransitiveTasksFinished = err => {
+			if (err) return callback(err);
+			this.processDependenciesQueue.decreaseParallelism();
+
+			return callback();
+		};
 
 		/**
 		 * @param {Dependency} dep dependency
@@ -1458,34 +1497,111 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.moduleGraph.setParents(dep, currentBlock, module, index);
 			if (this._unsafeCache) {
 				try {
-					const cachedModule = unsafeCacheDependencies.get(dep);
-					if (cachedModule === null) return;
-					if (cachedModule !== undefined) {
-						if (!this._restoredUnsafeCacheEntries.has(cachedModule)) {
-							const data = unsafeCacheData.get(cachedModule);
-							cachedModule.restoreFromUnsafeCache(
-								data,
-								this.params.normalModuleFactory,
-								this.params
+					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
+					if (unsafeCachedModule === null) return;
+					if (unsafeCachedModule !== undefined) {
+						if (
+							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
+						) {
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								unsafeCachedModule
+							);
+							return;
+						}
+						const identifier = unsafeCachedModule.identifier();
+						const cachedModule =
+							this._restoredUnsafeCacheEntries.get(identifier);
+						if (cachedModule !== undefined) {
+							// update unsafe cache to new module
+							unsafeCacheDependencies.set(dep, cachedModule);
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								cachedModule
 							);
-							this._restoredUnsafeCacheEntries.add(cachedModule);
-							if (!this.modules.has(cachedModule)) {
-								this._handleNewModuleFromUnsafeCache(module, dep, cachedModule);
-								unsafeRestoredModules.add(cachedModule);
+							return;
+						}
+						inProgressSorting++;
+						this._modulesCache.get(identifier, null, (err, cachedModule) => {
+							if (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
 								return;
 							}
-						}
-						this._handleExistingModuleFromUnsafeCache(
-							module,
-							dep,
-							cachedModule
-						);
+							try {
+								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
+									const data = unsafeCacheData.get(cachedModule);
+									if (data === undefined) {
+										processDependencyForResolving(dep);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+									if (cachedModule !== unsafeCachedModule) {
+										unsafeCacheDependencies.set(dep, cachedModule);
+									}
+									cachedModule.restoreFromUnsafeCache(
+										data,
+										this.params.normalModuleFactory,
+										this.params
+									);
+									this._restoredUnsafeCacheEntries.set(
+										identifier,
+										cachedModule
+									);
+									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
+									if (!this.modules.has(cachedModule)) {
+										inProgressTransitive++;
+										this._handleNewModuleFromUnsafeCache(
+											module,
+											dep,
+											cachedModule,
+											err => {
+												if (err) {
+													if (inProgressTransitive <= 0) return;
+													inProgressTransitive = -1;
+													onTransitiveTasksFinished(err);
+												}
+												if (--inProgressTransitive === 0)
+													return onTransitiveTasksFinished();
+											}
+										);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+								}
+								if (unsafeCachedModule !== cachedModule) {
+									unsafeCacheDependencies.set(dep, cachedModule);
+								}
+								this._handleExistingModuleFromUnsafeCache(
+									module,
+									dep,
+									cachedModule
+								); // a3
+							} catch (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							if (--inProgressSorting === 0) onDependenciesSorted();
+						});
 						return;
 					}
 				} catch (e) {
 					console.error(e);
 				}
 			}
+			processDependencyForResolving(dep);
+		};
+
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
+		const processDependencyForResolving = dep => {
 			const resourceIdent = dep.getResourceIdentifier();
 			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
@@ -1570,68 +1686,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			return callback(e);
 		}
 
-		if (sortedDependencies.length === 0 && unsafeRestoredModules.size === 0) {
-			callback();
-			return;
-		}
-
-		// This is nested so we need to allow one additional task
-		this.processDependenciesQueue.increaseParallelism();
-
-		const processSortedDependency = (item, callback) => {
-			this.handleModuleCreation(item, err => {
-				// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
-				// errors are created inside closures that keep a reference to the Compilation, so errors are
-				// leaking the Compilation object.
-				if (err && this.bail) {
-					// eslint-disable-next-line no-self-assign
-					err.stack = err.stack;
-					return callback(err);
-				}
-				callback();
-			});
-		};
-
-		const processUnsafeRestoredModule = (item, callback) => {
-			this._handleModuleBuildAndDependencies(module, item, true, callback);
-		};
-
-		const finalCallback = err => {
-			this.processDependenciesQueue.decreaseParallelism();
-
-			return callback(err);
-		};
-
-		if (sortedDependencies.length === 0) {
-			asyncLib.forEach(
-				unsafeRestoredModules,
-				processUnsafeRestoredModule,
-				finalCallback
-			);
-		} else if (unsafeRestoredModules.size === 0) {
-			asyncLib.forEach(
-				sortedDependencies,
-				processSortedDependency,
-				finalCallback
-			);
-		} else {
-			asyncLib.parallel(
-				[
-					cb =>
-						asyncLib.forEach(
-							unsafeRestoredModules,
-							processUnsafeRestoredModule,
-							cb
-						),
-					cb =>
-						asyncLib.forEach(sortedDependencies, processSortedDependency, cb)
-				],
-				finalCallback
-			);
-		}
+		if (--inProgressSorting === 0) onDependenciesSorted();
 	}
 
-	_handleNewModuleFromUnsafeCache(originModule, dependency, module) {
+	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
 		const moduleGraph = this.moduleGraph;
 
 		moduleGraph.setResolvedModule(originModule, dependency, module);
@@ -1644,6 +1702,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._modules.set(module.identifier(), module);
 		this.modules.add(module);
 		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+		this._handleModuleBuildAndDependencies(
+			originModule,
+			module,
+			true,
+			callback
+		);
 	}
 
 	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
@@ -1747,20 +1812,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						/** @type {any} */ (module).restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
+						const unsafeCacheableModule =
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
+								module
+							);
 						for (let i = 0; i < dependencies.length; i++) {
 							const dependency = dependencies[i];
 							moduleGraph.setResolvedModule(
 								connectOrigin ? originModule : null,
 								dependency,
-								module
-							);
-							unsafeCacheDependencies.set(
-								dependency,
-								/** @type {any} */ (module)
+								unsafeCacheableModule
 							);
+							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
 						}
-						if (!unsafeCacheData.has(module)) {
-							unsafeCacheData.set(module, module.getUnsafeCacheData());
+						if (!unsafeCacheData.has(unsafeCacheableModule)) {
+							unsafeCacheData.set(
+								unsafeCacheableModule,
+								unsafeCacheableModule.getUnsafeCacheData()
+							);
 						}
 					} else {
 						applyFactoryResultDependencies();
@@ -1814,7 +1883,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					creatingModuleDuringBuildSet
 				);
 			}
-			creatingModuleDuringBuildSet.add(originModule);
+			creatingModuleDuringBuildSet.add(module);
 
 			// When building is blocked by another module
 			// search for a cycle, cancel the cycle by throwing
@@ -3633,7 +3702,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.moduleGraph.removeConnection(dep);
 
 					if (this.chunkGraph) {
-						for (const chunk of this.chunkGraph.getModuleChunksIterable(
+						for (const chunk of this.chunkGraph.getModuleChunks(
 							originalModule
 						)) {
 							this.patchChunksAfterReasonRemoval(originalModule, chunk);
@@ -4618,21 +4687,18 @@ This prevents using hashes of each other and should be avoided.`);
 			 * @returns {void}
 			 */
 			(module, push, callback) => {
-				this.addModuleQueue.waitFor(module, err => {
+				this.buildQueue.waitFor(module, err => {
 					if (err) return callback(err);
-					this.buildQueue.waitFor(module, err => {
+					this.processDependenciesQueue.waitFor(module, err => {
 						if (err) return callback(err);
-						this.processDependenciesQueue.waitFor(module, err => {
-							if (err) return callback(err);
-							for (const {
-								module: m
-							} of this.moduleGraph.getOutgoingConnections(module)) {
-								const size = modules.size;
-								modules.add(m);
-								if (modules.size !== size) push(m);
-							}
-							callback();
-						});
+						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
+							module
+						)) {
+							const size = modules.size;
+							modules.add(m);
+							if (modules.size !== size) push(m);
+						}
+						callback();
 					});
 				});
 			},

package/lib/Compiler.js

@@ -219,9 +219,9 @@ class Compiler {
 		/** @type {string|null} */
 		this.recordsOutputPath = null;
 		this.records = {};
-		/** @type {Set<string>} */
+		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set();
-		/** @type {Set<string>} */
+		/** @type {Set<string | RegExp>} */
 		this.immutablePaths = new Set();
 
 		/** @type {ReadonlySet<string>} */

package/lib/DefinePlugin.js

@@ -151,7 +151,7 @@ const stringifyObj = (
 		case false:
 			return arr ? `;${code}` : `;(${code})`;
 		default:
-			return `Object(${code})`;
+			return `/*#__PURE__*/Object(${code})`;
 	}
 };