webpack 5.58.1 → 5.58.2

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
 							);
-							this._restoredUnsafeCacheEntries.add(cachedModule);
-							if (!this.modules.has(cachedModule)) {
-								this._handleNewModuleFromUnsafeCache(module, dep, cachedModule);
-								unsafeRestoredModules.add(cachedModule);
+							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
+							);
+							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();

package/lib/FileSystemInfo.js

@@ -206,17 +206,17 @@ class Snapshot {
 		this._flags = 0;
 		/** @type {number | undefined} */
 		this.startTime = undefined;
-		/** @type {Map<string, FileSystemInfoEntry> | undefined} */
+		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
 		this.fileTimestamps = undefined;
-		/** @type {Map<string, string> | undefined} */
+		/** @type {Map<string, string | null> | undefined} */
 		this.fileHashes = undefined;
-		/** @type {Map<string, TimestampAndHash | string> | undefined} */
+		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
 		this.fileTshs = undefined;
-		/** @type {Map<string, ResolvedContextFileSystemInfoEntry> | undefined} */
+		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
 		this.contextTimestamps = undefined;
-		/** @type {Map<string, string> | undefined} */
+		/** @type {Map<string, string | null> | undefined} */
 		this.contextHashes = undefined;
-		/** @type {Map<string, ResolvedContextTimestampAndHash> | undefined} */
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
 		this.contextTshs = undefined;
 		/** @type {Map<string, boolean> | undefined} */
 		this.missingExistence = undefined;
@@ -823,11 +823,10 @@ const getManagedItem = (managedPath, path) => {
 
 /**
  * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
- * @param {T | "ignore"} entry entry
+ * @param {T} entry entry
  * @returns {T["resolved"] | undefined} the resolved entry
  */
 const getResolvedTimestamp = entry => {
-	if (entry === "ignore") return undefined;
 	if (entry === null) return null;
 	if (entry.resolved !== undefined) return entry.resolved;
 	return entry.symlinks === undefined ? entry : undefined;
@@ -1191,6 +1190,7 @@ class FileSystemInfo {
 	getContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
 		if (cache !== undefined) {
+			if (cache === "ignore") return callback(null, "ignore");
 			const resolved = getResolvedTimestamp(cache);
 			if (resolved !== undefined) return callback(null, resolved);
 			return this._resolveContextTimestamp(cache, callback);
@@ -1876,17 +1876,17 @@ class FileSystemInfo {
 	 * @returns {void}
 	 */
 	createSnapshot(startTime, files, directories, missing, options, callback) {
-		/** @type {Map<string, FileSystemInfoEntry>} */
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
 		const fileTimestamps = new Map();
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, string | null>} */
 		const fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string>} */
+		/** @type {Map<string, TimestampAndHash | string | null>} */
 		const fileTshs = new Map();
-		/** @type {Map<string, FileSystemInfoEntry>} */
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
 		const contextTimestamps = new Map();
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, string | null>} */
 		const contextHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string>} */
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
 		const contextTshs = new Map();
 		/** @type {Map<string, boolean>} */
 		const missingExistence = new Map();
@@ -2080,6 +2080,7 @@ class FileSystemInfo {
 					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTshs.get(path);
+						/** @type {ResolvedContextTimestampAndHash} */
 						let resolved;
 						if (
 							cache !== undefined &&
@@ -2088,6 +2089,11 @@ class FileSystemInfo {
 							contextTshs.set(path, resolved);
 						} else {
 							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextTimestampAndHash=} entry entry
+							 * @returns {void}
+							 */
 							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
@@ -2152,14 +2158,20 @@ class FileSystemInfo {
 					);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTimestamps.get(path);
+						if (cache === "ignore") continue;
 						let resolved;
 						if (
 							cache !== undefined &&
 							(resolved = getResolvedTimestamp(cache)) !== undefined
 						) {
 							contextTimestamps.set(path, resolved);
-						} else if (cache !== "ignore") {
+						} else {
 							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+							 * @returns {void}
+							 */
 							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
@@ -2572,14 +2584,14 @@ class FileSystemInfo {
 					const cache = this._fileTimestamps.get(path);
 					if (cache !== undefined) {
 						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
-							processFileHashSnapshot(path, tsh.hash);
+							processFileHashSnapshot(path, tsh && tsh.hash);
 						}
 					} else {
 						jobs++;
 						this.fileTimestampQueue.add(path, (err, entry) => {
 							if (err) return invalidWithError(path, err);
 							if (!checkFile(path, entry, tsh, false)) {
-								processFileHashSnapshot(path, tsh.hash);
+								processFileHashSnapshot(path, tsh && tsh.hash);
 							}
 							jobDone();
 						});
@@ -2592,6 +2604,7 @@ class FileSystemInfo {
 			this._statTestedEntries += contextTimestamps.size;
 			for (const [path, ts] of contextTimestamps) {
 				const cache = this._contextTimestamps.get(path);
+				if (cache === "ignore") continue;
 				let resolved;
 				if (
 					cache !== undefined &&
@@ -2601,8 +2614,13 @@ class FileSystemInfo {
 						invalid();
 						return;
 					}
-				} else if (cache !== "ignore") {
+				} else {
 					jobs++;
+					/**
+					 * @param {Error=} err error
+					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+					 * @returns {void}
+					 */
 					const callback = (err, entry) => {
 						if (err) return invalidWithError(path, err);
 						if (!checkContext(path, entry, ts)) {
@@ -2662,27 +2680,33 @@ class FileSystemInfo {
 					processContextHashSnapshot(path, tsh);
 				} else {
 					const cache = this._contextTimestamps.get(path);
+					if (cache === "ignore") continue;
 					let resolved;
 					if (
 						cache !== undefined &&
 						(resolved = getResolvedTimestamp(cache)) !== undefined
 					) {
 						if (!checkContext(path, resolved, tsh, false)) {
-							processContextHashSnapshot(path, tsh.hash);
+							processContextHashSnapshot(path, tsh && tsh.hash);
 						}
-					} else if (cache !== "ignore") {
+					} else {
 						jobs++;
+						/**
+						 * @param {Error=} err error
+						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+						 * @returns {void}
+						 */
 						const callback = (err, entry) => {
 							if (err) return invalidWithError(path, err);
 							if (!checkContext(path, entry, tsh, false)) {
-								processContextHashSnapshot(path, tsh.hash);
+								processContextHashSnapshot(path, tsh && tsh.hash);
 							}
 							jobDone();
 						};
 						if (cache !== undefined) {
-							this._resolveContextTsh(cache, callback);
+							this._resolveContextTimestamp(cache, callback);
 						} else {
-							this.getContextTsh(path, callback);
+							this.getContextTimestamp(path, callback);
 						}
 					}
 				}
@@ -3032,6 +3056,11 @@ class FileSystemInfo {
 		);
 	}
 
+	/**
+	 * @param {ContextFileSystemInfoEntry} entry entry
+	 * @param {function(Error=, ResolvedContextFileSystemInfoEntry=): void} callback callback
+	 * @returns {void}
+	 */
 	_resolveContextTimestamp(entry, callback) {
 		const hashes = [];
 		let safeTime = 0;
@@ -3135,6 +3164,11 @@ class FileSystemInfo {
 		);
 	}
 
+	/**
+	 * @param {ContextHash} entry context hash
+	 * @param {function(Error=, string=): void} callback callback
+	 * @returns {void}
+	 */
 	_resolveContextHash(entry, callback) {
 		const hashes = [];
 		processAsyncTree(
@@ -3286,6 +3320,11 @@ class FileSystemInfo {
 		}
 	}
 
+	/**
+	 * @param {ContextTimestampAndHash} entry entry
+	 * @param {function(Error=, ResolvedContextTimestampAndHash=): void} callback callback
+	 * @returns {void}
+	 */
 	_resolveContextTsh(entry, callback) {
 		const hashes = [];
 		const tsHashes = [];

package/lib/optimize/SplitChunksPlugin.js

@@ -774,9 +774,13 @@ module.exports = class SplitChunksPlugin {
 					const chunkIndexMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
-					let index = ONE;
+					const START = ONE << BigInt("31");
+					let index = START;
 					for (const chunk of chunks) {
-						chunkIndexMap.set(chunk, index);
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
 						index = index << ONE;
 					}
 					/**
@@ -793,7 +797,8 @@ module.exports = class SplitChunksPlugin {
 						let key =
 							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
 						while (!(result = iterator.next()).done) {
-							key = key | chunkIndexMap.get(result.value);
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
 						}
 						return key;
 					};

package/lib/serialization/Serializer.js

@@ -16,9 +16,7 @@ class Serializer {
 		let current = obj;
 		for (const middleware of this.serializeMiddlewares) {
 			if (current && typeof current.then === "function") {
-				current = current.then(
-					data => data && middleware.serialize(data, context)
-				);
+				current = current.then(data => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
 					current = middleware.serialize(current, ctx);
@@ -36,7 +34,7 @@ class Serializer {
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, context));
+				current = current.then(data => middleware.deserialize(data, ctx));
 			} else {
 				current = middleware.deserialize(current, ctx);
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.58.1",
+  "version": "5.58.2",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",

package/types.d.ts

@@ -10448,12 +10448,12 @@ declare class SizeOnlySource extends Source {
 }
 declare abstract class Snapshot {
 	startTime?: number;
-	fileTimestamps?: Map<string, FileSystemInfoEntry>;
-	fileHashes?: Map<string, string>;
-	fileTshs?: Map<string, string | TimestampAndHash>;
-	contextTimestamps?: Map<string, ResolvedContextFileSystemInfoEntry>;
-	contextHashes?: Map<string, string>;
-	contextTshs?: Map<string, ResolvedContextTimestampAndHash>;
+	fileTimestamps?: Map<string, null | FileSystemInfoEntry>;
+	fileHashes?: Map<string, null | string>;
+	fileTshs?: Map<string, null | string | TimestampAndHash>;
+	contextTimestamps?: Map<string, null | ResolvedContextFileSystemInfoEntry>;
+	contextHashes?: Map<string, null | string>;
+	contextTshs?: Map<string, null | ResolvedContextTimestampAndHash>;
 	missingExistence?: Map<string, boolean>;
 	managedItemInfo?: Map<string, string>;
 	managedFiles?: Set<string>;