webpack 5.106.2 → 5.107.0

package/lib/FileSystemInfo.js

@@ -20,14 +20,14 @@ const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./errors/WebpackError")} WebpackError */
 /** @typedef {import("./util/fs").JsonObject} JsonObject */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /**
  * Defines the processor callback type used by this module.
  * @template T
@@ -231,7 +231,7 @@ class SnapshotIterable {
 							const map = maps.pop();
 							if (map !== undefined) {
 								it =
-									/** @type {Set<EXPECTED_ANY> | Map<string, EXPECTED_ANY>} */
+									/** @type {Set<string> | Map<string, EXPECTED_ANY>} */
 									(map).keys();
 								state = 2;
 							} else {
@@ -1111,10 +1111,26 @@ const getEsModuleLexer = memoize(() => require("es-module-lexer"));
 
 /** @typedef {Set<string>} LoggedPaths */
 
-/** @typedef {FileSystemInfoEntry | "ignore" | null} FileTimestamp */
-/** @typedef {ContextFileSystemInfoEntry | "ignore" | null} ContextTimestamp */
+/** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */
+/** @typedef {ContextFileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} ContextTimestamp */
 /** @typedef {ResolvedContextFileSystemInfoEntry | "ignore" | null} ResolvedContextTimestamp */
 
+/**
+ * `watchpack` may report `{}` (existence-only) for files and directories it
+ * is watching but has no time information for. Such entries cannot be used
+ * for snapshot comparison, so cache lookups treat them as "no cached value"
+ * and fall back to a fresh on-disk read.
+ * @param {FileTimestamp | ContextTimestamp | undefined} entry cache entry
+ * @returns {entry is ExistenceOnlyTimeEntry} true if the entry exists but carries no time info
+ */
+const isExistenceOnly = (entry) => {
+	if (entry === undefined || entry === null || entry === "ignore") return false;
+	return (
+		/** @type {Partial<FileSystemInfoEntry> & Partial<ContextFileSystemInfoEntry>} */
+		(entry).safeTime === undefined
+	);
+};
+
 /** @typedef {(err?: WebpackError | null, result?: boolean) => void} CheckSnapshotValidCallback */
 
 /**
@@ -1463,43 +1479,40 @@ class FileSystemInfo {
 
 	/**
 	 * Adds file timestamps.
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null>} map timestamps
+	 * @param {ReadonlyMap<string, FileTimestamp>} map timestamps
 	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
 	addFileTimestamps(map, immutable) {
-		this._fileTimestamps.addAll(
-			/** @type {ReadonlyMap<string, FileTimestamp>} */
-			(map),
-			immutable
-		);
+		this._fileTimestamps.addAll(map, immutable);
 		this._cachedDeprecatedFileTimestamps = undefined;
 	}
 
 	/**
 	 * Adds context timestamps.
-	 * @param {ReadonlyMap<string, ContextFileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null>} map timestamps
+	 * @param {ReadonlyMap<string, ContextTimestamp>} map timestamps
 	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
 	addContextTimestamps(map, immutable) {
-		this._contextTimestamps.addAll(
-			/** @type {ReadonlyMap<string, ContextTimestamp>} */
-			(map),
-			immutable
-		);
+		this._contextTimestamps.addAll(map, immutable);
 		this._cachedDeprecatedContextTimestamps = undefined;
 	}
 
 	/**
 	 * Gets file timestamp.
 	 * @param {string} path file path
-	 * @param {(err?: WebpackError | null, fileTimestamp?: FileTimestamp) => void} callback callback function
+	 * @param {(err?: WebpackError | null, fileTimestamp?: FileSystemInfoEntry | "ignore" | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	getFileTimestamp(path, callback) {
 		const cache = this._fileTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
+		if (cache !== undefined && !isExistenceOnly(cache)) {
+			return callback(
+				null,
+				/** @type {FileSystemInfoEntry | "ignore" | null} */ (cache)
+			);
+		}
 		this.fileTimestampQueue.add(path, callback);
 	}
 
@@ -1511,19 +1524,38 @@ class FileSystemInfo {
 	 */
 	getContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) {
+		if (cache !== undefined && !isExistenceOnly(cache)) {
 			if (cache === "ignore") return callback(null, "ignore");
-			const resolved = getResolvedTimestamp(cache);
+			const fullEntry =
+				/** @type {ContextFileSystemInfoEntry | null} */
+				(cache);
+			const resolved = getResolvedTimestamp(fullEntry);
 			if (resolved !== undefined) return callback(null, resolved);
 			return this._resolveContextTimestamp(
-				/** @type {ResolvedContextFileSystemInfoEntry} */
-				(cache),
+				/** @type {ContextFileSystemInfoEntry} */
+				(fullEntry),
 				callback
 			);
 		}
+		this._readFreshContextTimestamp(path, callback);
+	}
+
+	/**
+	 * Reads a context timestamp directly from disk, bypassing any cached
+	 * entry. Used by `getContextTimestamp` and the snapshot validity
+	 * checks when the cached entry is missing or is an `ExistenceOnlyTimeEntry`
+	 * (`{}`) supplied by watchpack — both cases require a fresh read to
+	 * obtain the `timestampHash`.
+	 * @private
+	 * @param {string} path context path
+	 * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback function
+	 * @returns {void}
+	 */
+	_readFreshContextTimestamp(path, callback) {
 		this.contextTimestampQueue.add(path, (err, _entry) => {
 			if (err) return callback(err);
-			const entry = /** @type {ContextFileSystemInfoEntry} */ (_entry);
+			const entry = /** @type {ContextFileSystemInfoEntry | null} */ (_entry);
+			if (entry === null) return callback(null, null);
 			const resolved = getResolvedTimestamp(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextTimestamp(entry, callback);
@@ -1531,15 +1563,22 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * Get unresolved context timestamp.
+	 * Get unresolved context timestamp. Existence-only cache entries (`{}`)
+	 * are bypassed so the callback always receives a complete entry, "ignore"
+	 * or null.
 	 * @private
 	 * @param {string} path context path
-	 * @param {(err?: WebpackError | null, contextTimestamp?: ContextTimestamp) => void} callback callback function
+	 * @param {(err?: WebpackError | null, contextTimestamp?: ContextFileSystemInfoEntry | "ignore" | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
+		if (cache !== undefined && !isExistenceOnly(cache)) {
+			return callback(
+				null,
+				/** @type {ContextFileSystemInfoEntry | "ignore" | null} */ (cache)
+			);
+		}
 		this.contextTimestampQueue.add(path, callback);
 	}
 
@@ -1637,20 +1676,20 @@ class FileSystemInfo {
 		});
 		const resolveCjs = createResolver({
 			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
+			conditionNames: ["require", "module-sync", "node"],
 			exportsFields: ["exports"],
 			fileSystem: this.fs
 		});
 		const resolveCjsAsChild = createResolver({
 			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
+			conditionNames: ["require", "module-sync", "node"],
 			exportsFields: [],
 			fileSystem: this.fs
 		});
 		const resolveEsm = createResolver({
 			extensions: [".js", ".json", ".node"],
 			fullySpecified: true,
-			conditionNames: ["import", "node"],
+			conditionNames: ["import", "module-sync", "node"],
 			exportsFields: ["exports"],
 			fileSystem: this.fs
 		});
@@ -2503,9 +2542,12 @@ class FileSystemInfo {
 					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
 					for (const path of capturedFiles) {
 						const cache = this._fileTimestamps.get(path);
-						if (cache !== undefined) {
+						if (cache !== undefined && !isExistenceOnly(cache)) {
 							if (cache !== "ignore") {
-								fileTimestamps.set(path, cache);
+								fileTimestamps.set(
+									path,
+									/** @type {FileSystemInfoEntry | null} */ (cache)
+								);
 							}
 						} else {
 							jobs++;
@@ -2637,19 +2679,33 @@ class FileSystemInfo {
 					for (const path of capturedDirectories) {
 						const cache = this._contextTimestamps.get(path);
 						if (cache === "ignore") continue;
+						/** @type {ContextFileSystemInfoEntry | null | undefined} */
+						const usableCache =
+							cache === undefined || isExistenceOnly(cache)
+								? undefined
+								: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
+						// A non-null cache entry without `timestampHash` cannot be
+						// used to populate the snapshot — the snapshot would then
+						// miss directory-change detection, since validity relies on
+						// `timestampHash`. Re-read the directory in that case.
+						const cacheLacksHash =
+							usableCache !== undefined &&
+							usableCache !== null &&
+							usableCache.timestampHash === undefined;
 						/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
 						let resolved;
 						if (
-							cache !== undefined &&
-							(resolved = getResolvedTimestamp(cache)) !== undefined
+							usableCache !== undefined &&
+							!cacheLacksHash &&
+							(resolved = getResolvedTimestamp(usableCache)) !== undefined
 						) {
 							contextTimestamps.set(path, resolved);
 						} else {
 							jobs++;
 							/**
 							 * Processes the provided err.
-							 * @param {(Error | null)=} err error
-							 * @param {FileTimestamp=} entry entry
+							 * @param {(WebpackError | null)=} err error
+							 * @param {ResolvedContextTimestamp=} entry entry
 							 * @returns {void}
 							 */
 							const callback = (err, entry) => {
@@ -2663,20 +2719,20 @@ class FileSystemInfo {
 								} else {
 									contextTimestamps.set(
 										path,
-										/** @type {FileSystemInfoEntry | null} */
+										/** @type {ResolvedContextFileSystemInfoEntry | null} */
 										(entry)
 									);
 									jobDone();
 								}
 							};
-							if (cache !== undefined) {
-								this._resolveContextTimestamp(
-									/** @type {ContextFileSystemInfoEntry} */
-									(cache),
-									callback
-								);
+							if (cacheLacksHash) {
+								this._readFreshContextTimestamp(path, callback);
+							} else if (usableCache !== undefined && usableCache !== null) {
+								this._resolveContextTimestamp(usableCache, callback);
 							} else {
-								this.getContextTimestamp(path, callback);
+								// Force a fresh on-disk read so the snapshot stores a
+								// complete entry (with `timestampHash`).
+								this._readFreshContextTimestamp(path, callback);
 							}
 						}
 					}
@@ -2699,7 +2755,7 @@ class FileSystemInfo {
 			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
 			for (const path of capturedMissing) {
 				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
+				if (cache !== undefined && !isExistenceOnly(cache)) {
 					if (cache !== "ignore") {
 						missingExistence.set(path, Boolean(cache));
 					}
@@ -3092,8 +3148,15 @@ class FileSystemInfo {
 			this._statTestedEntries += fileTimestamps.size;
 			for (const [path, ts] of fileTimestamps) {
 				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
+				if (cache !== undefined && !isExistenceOnly(cache)) {
+					if (
+						cache !== "ignore" &&
+						!checkFile(
+							path,
+							/** @type {FileSystemInfoEntry | null} */ (cache),
+							ts
+						)
+					) {
 						invalid();
 						return;
 					}
@@ -3154,8 +3217,16 @@ class FileSystemInfo {
 					processFileHashSnapshot(path, tsh);
 				} else {
 					const cache = this._fileTimestamps.get(path);
-					if (cache !== undefined) {
-						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
+					if (cache !== undefined && !isExistenceOnly(cache)) {
+						if (
+							cache === "ignore" ||
+							!checkFile(
+								path,
+								/** @type {FileSystemInfoEntry | null} */ (cache),
+								tsh,
+								false
+							)
+						) {
 							processFileHashSnapshot(path, tsh && tsh.hash);
 						}
 					} else {
@@ -3187,11 +3258,29 @@ class FileSystemInfo {
 			for (const [path, ts] of contextTimestamps) {
 				const cache = this._contextTimestamps.get(path);
 				if (cache === "ignore") continue;
+				// Treat existence-only entries (`{}` from watchpack) as a cache
+				// miss — they carry no time info, so we cannot compare them to
+				// the snapshot.
+				/** @type {ContextFileSystemInfoEntry | null | undefined} */
+				const usableCache =
+					cache === undefined || isExistenceOnly(cache)
+						? undefined
+						: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
+				// A non-null cache entry that lacks `timestampHash` while the
+				// snapshot has one cannot be used either; we re-read the
+				// directory through the disk-backed queue instead.
+				const cacheLacksHash =
+					usableCache !== undefined &&
+					usableCache !== null &&
+					usableCache.timestampHash === undefined &&
+					ts !== null &&
+					ts.timestampHash !== undefined;
 				/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
 				let resolved;
 				if (
-					cache !== undefined &&
-					(resolved = getResolvedTimestamp(cache)) !== undefined
+					usableCache !== undefined &&
+					!cacheLacksHash &&
+					(resolved = getResolvedTimestamp(usableCache)) !== undefined
 				) {
 					if (!checkContext(path, resolved, ts)) {
 						invalid();
@@ -3220,12 +3309,10 @@ class FileSystemInfo {
 							jobDone();
 						}
 					};
-					if (cache !== undefined) {
-						this._resolveContextTimestamp(
-							/** @type {ContextFileSystemInfoEntry} */
-							(cache),
-							callback
-						);
+					if (cacheLacksHash) {
+						this._readFreshContextTimestamp(path, callback);
+					} else if (usableCache !== undefined && usableCache !== null) {
+						this._resolveContextTimestamp(usableCache, callback);
 					} else {
 						this.getContextTimestamp(path, callback);
 					}
@@ -3289,11 +3376,24 @@ class FileSystemInfo {
 				} else {
 					const cache = this._contextTimestamps.get(path);
 					if (cache === "ignore") continue;
+					// See the matching block in `hasContextTimestamps` above.
+					/** @type {ContextFileSystemInfoEntry | null | undefined} */
+					const usableCache =
+						cache === undefined || isExistenceOnly(cache)
+							? undefined
+							: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
+					const cacheLacksHash =
+						usableCache !== undefined &&
+						usableCache !== null &&
+						usableCache.timestampHash === undefined &&
+						tsh !== null &&
+						tsh.timestampHash !== undefined;
 					/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
 					let resolved;
 					if (
-						cache !== undefined &&
-						(resolved = getResolvedTimestamp(cache)) !== undefined
+						usableCache !== undefined &&
+						!cacheLacksHash &&
+						(resolved = getResolvedTimestamp(usableCache)) !== undefined
 					) {
 						if (!checkContext(path, resolved, tsh, false)) {
 							processContextHashSnapshot(path, tsh && tsh.hash);
@@ -3322,12 +3422,10 @@ class FileSystemInfo {
 							}
 							jobDone();
 						};
-						if (cache !== undefined) {
-							this._resolveContextTimestamp(
-								/** @type {ContextFileSystemInfoEntry} */
-								(cache),
-								callback
-							);
+						if (cacheLacksHash) {
+							this._readFreshContextTimestamp(path, callback);
+						} else if (usableCache !== undefined && usableCache !== null) {
+							this._resolveContextTimestamp(usableCache, callback);
 						} else {
 							this.getContextTimestamp(path, callback);
 						}
@@ -3342,7 +3440,7 @@ class FileSystemInfo {
 			this._statTestedEntries += missingExistence.size;
 			for (const [path, existence] of missingExistence) {
 				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
+				if (cache !== undefined && !isExistenceOnly(cache)) {
 					if (
 						cache !== "ignore" &&
 						!checkExistence(path, Boolean(cache), Boolean(existence))
@@ -3672,8 +3770,13 @@ class FileSystemInfo {
 				fromFile: (file, stat, callback) => {
 					// Prefer the cached value over our new stat to report consistent results
 					const cache = this._fileTimestamps.get(file);
-					if (cache !== undefined) {
-						return callback(null, cache === "ignore" ? null : cache);
+					if (cache !== undefined && !isExistenceOnly(cache)) {
+						return callback(
+							null,
+							cache === "ignore"
+								? null
+								: /** @type {FileSystemInfoEntry | null} */ (cache)
+						);
 					}
 
 					const mtime = Number(stat.mtime);
@@ -4216,7 +4319,13 @@ class FileSystemInfo {
 		/** @type {Map<string, number | null>} */
 		const map = new Map();
 		for (const [path, info] of this._fileTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
+			if (info) {
+				const safeTime =
+					typeof info === "object"
+						? /** @type {Partial<FileSystemInfoEntry>} */ (info).safeTime
+						: undefined;
+				map.set(path, safeTime === undefined ? null : safeTime);
+			}
 		}
 		return (this._cachedDeprecatedFileTimestamps = map);
 	}
@@ -4228,7 +4337,13 @@ class FileSystemInfo {
 		/** @type {Map<string, number | null>} */
 		const map = new Map();
 		for (const [path, info] of this._contextTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
+			if (info) {
+				const safeTime =
+					typeof info === "object"
+						? /** @type {Partial<ContextFileSystemInfoEntry>} */ (info).safeTime
+						: undefined;
+				map.set(path, safeTime === undefined ? null : safeTime);
+			}
 		}
 		return (this._cachedDeprecatedContextTimestamps = map);
 	}

package/lib/Generator.js

@@ -74,7 +74,7 @@ class Generator {
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
@@ -88,7 +88,7 @@ class Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
@@ -105,7 +105,7 @@ class Generator {
 		module,
 		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
 	) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/HotModuleReplacementPlugin.js

@@ -18,18 +18,19 @@ const {
 } = require("./ModuleTypeConstants");
 const NormalModule = require("./NormalModule");
 const RuntimeGlobals = require("./RuntimeGlobals");
-const WebpackError = require("./WebpackError");
 const { chunkHasCss } = require("./css/CssModulesPlugin");
 const ConstDependency = require("./dependencies/ConstDependency");
 const ImportMetaHotAcceptDependency = require("./dependencies/ImportMetaHotAcceptDependency");
 const ImportMetaHotDeclineDependency = require("./dependencies/ImportMetaHotDeclineDependency");
 const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDependency");
 const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency");
+const WebpackError = require("./errors/WebpackError");
 const HotModuleReplacementRuntimeModule = require("./hmr/HotModuleReplacementRuntimeModule");
 const JavascriptParser = require("./javascript/JavascriptParser");
 const {
 	evaluateToIdentifier
 } = require("./javascript/JavascriptParserHelpers");
+const ConcatenatedModule = require("./optimize/ConcatenatedModule");
 const { find, isSubset } = require("./util/SetHelpers");
 const TupleSet = require("./util/TupleSet");
 const { compareModulesById } = require("./util/comparators");
@@ -389,13 +390,30 @@ class HotModuleReplacementPlugin {
 					for (const chunk of compilation.chunks) {
 						const chunkId = /** @type {ChunkId} */ (chunk.id);
 
-						records.chunkModuleIds[chunkId] = Array.from(
-							chunkGraph.getOrderedChunkModulesIterable(
-								chunk,
-								compareModulesById(chunkGraph)
-							),
-							(m) => /** @type {ModuleId} */ (chunkGraph.getModuleId(m))
-						);
+						/** @type {ModuleId[]} */
+						const moduleIds = [];
+						for (const m of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesById(chunkGraph)
+						)) {
+							moduleIds.push(
+								/** @type {ModuleId} */ (chunkGraph.getModuleId(m))
+							);
+							if (m instanceof ConcatenatedModule && m.modules) {
+								for (const innerModule of m.modules) {
+									if (
+										innerModule.buildMeta &&
+										innerModule.buildMeta.needIdInConcatenation
+									) {
+										const innerId = chunkGraph.getModuleId(innerModule);
+										if (innerId !== null) {
+											moduleIds.push(innerId);
+										}
+									}
+								}
+							}
+						}
+						records.chunkModuleIds[chunkId] = moduleIds;
 					}
 				});
 				/** @type {TupleSet<Module, Chunk>} */

package/lib/IgnorePlugin.js

@@ -66,7 +66,8 @@ class IgnorePlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				require("../schemas/plugins/IgnorePlugin.json"),
+				/** @type {EXPECTED_ANY} */
+				(require("../schemas/plugins/IgnorePlugin.json")),
 				this.options,
 				{
 					name: "Ignore Plugin",