webpack 5.57.1 → 5.59.0

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;
@@ -854,8 +853,8 @@ class FileSystemInfo {
 	/**
 	 * @param {InputFileSystem} fs file system
 	 * @param {Object} options options
-	 * @param {Iterable<string>=} options.managedPaths paths that are only managed by a package manager
-	 * @param {Iterable<string>=} options.immutablePaths paths that are immutable
+	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
+	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
 	 * @param {Logger=} options.logger logger used to log invalid snapshots
 	 * @param {string | Hash=} options.hashFunction the hash function to use
 	 */
@@ -997,12 +996,19 @@ class FileSystemInfo {
 			processor: this._getManagedItemDirectoryInfo.bind(this)
 		});
 		this.managedPaths = Array.from(managedPaths);
-		this.managedPathsWithSlash = this.managedPaths.map(p =>
-			join(fs, p, "_").slice(0, -1)
+		this.managedPathsWithSlash = /** @type {string[]} */ (
+			this.managedPaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+
+		this.managedPathsRegExps = /** @type {RegExp[]} */ (
+			this.managedPaths.filter(p => typeof p !== "string")
 		);
 		this.immutablePaths = Array.from(immutablePaths);
-		this.immutablePathsWithSlash = this.immutablePaths.map(p =>
-			join(fs, p, "_").slice(0, -1)
+		this.immutablePathsWithSlash = /** @type {string[]} */ (
+			this.immutablePaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
+			this.immutablePaths.filter(p => typeof p !== "string")
 		);
 
 		this._cachedDeprecatedFileTimestamps = undefined;
@@ -1191,6 +1197,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 +1883,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();
@@ -1966,12 +1973,29 @@ class FileSystemInfo {
 			}
 		};
 		const checkManaged = (path, managedSet) => {
+			for (const immutablePath of this.immutablePathsRegExps) {
+				if (immutablePath.test(path)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
 			for (const immutablePath of this.immutablePathsWithSlash) {
 				if (path.startsWith(immutablePath)) {
 					managedSet.add(path);
 					return true;
 				}
 			}
+			for (const managedPath of this.managedPathsRegExps) {
+				const match = managedPath.exec(path);
+				if (match) {
+					const managedItem = getManagedItem(managedPath[1], path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
+					}
+				}
+			}
 			for (const managedPath of this.managedPathsWithSlash) {
 				if (path.startsWith(managedPath)) {
 					const managedItem = getManagedItem(managedPath, path);
@@ -2080,6 +2104,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 +2113,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 +2182,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 +2608,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 +2628,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 +2638,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 +2704,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);
 						}
 					}
 				}
@@ -2899,10 +2947,29 @@ class FileSystemInfo {
 				files,
 				(file, callback) => {
 					const child = join(this.fs, path, file);
+					for (const immutablePath of this.immutablePathsRegExps) {
+						if (immutablePath.test(path)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
+						}
+					}
 					for (const immutablePath of this.immutablePathsWithSlash) {
 						if (path.startsWith(immutablePath)) {
 							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(immutablePath));
+							return callback(null, fromImmutablePath(path));
+						}
+					}
+					for (const managedPath of this.managedPathsRegExps) {
+						const match = managedPath.exec(path);
+						if (match) {
+							const managedItem = getManagedItem(managedPath[1], path);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
+							}
 						}
 					}
 					for (const managedPath of this.managedPathsWithSlash) {
@@ -3032,6 +3099,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 +3207,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 +3363,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/Module.js

@@ -885,6 +885,10 @@ class Module extends DependenciesBlock {
 		return true;
 	}
 
+	hasChunkCondition() {
+		return this.chunkCondition !== Module.prototype.chunkCondition;
+	}
+
 	/**
 	 * Assuming this module is in the cache. Update the (cached) module with
 	 * the fresh module from the factory. Usually updates internal references

package/lib/ModuleGraph.js

@@ -123,14 +123,6 @@ class ModuleGraph {
 		/** @type {WeakMap<any, Object>} */
 		this._metaMap = new WeakMap();
 
-		// Caching
-		this._cacheModuleGraphModuleKey1 = undefined;
-		this._cacheModuleGraphModuleValue1 = undefined;
-		this._cacheModuleGraphModuleKey2 = undefined;
-		this._cacheModuleGraphModuleValue2 = undefined;
-		this._cacheModuleGraphDependencyKey = undefined;
-		this._cacheModuleGraphDependencyValue = undefined;
-
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
 
@@ -143,19 +135,11 @@ class ModuleGraph {
 	 * @returns {ModuleGraphModule} the internal module
 	 */
 	_getModuleGraphModule(module) {
-		if (this._cacheModuleGraphModuleKey1 === module)
-			return this._cacheModuleGraphModuleValue1;
-		if (this._cacheModuleGraphModuleKey2 === module)
-			return this._cacheModuleGraphModuleValue2;
 		let mgm = this._moduleMap.get(module);
 		if (mgm === undefined) {
 			mgm = new ModuleGraphModule();
 			this._moduleMap.set(module, mgm);
 		}
-		this._cacheModuleGraphModuleKey2 = this._cacheModuleGraphModuleKey1;
-		this._cacheModuleGraphModuleValue2 = this._cacheModuleGraphModuleValue1;
-		this._cacheModuleGraphModuleKey1 = module;
-		this._cacheModuleGraphModuleValue1 = mgm;
 		return mgm;
 	}
 
@@ -163,9 +147,11 @@ class ModuleGraph {
 	 * @param {Dependency} dependency the dependency
 	 * @param {DependenciesBlock} block parent block
 	 * @param {Module} module parent module
+	 * @param {number=} indexInBlock position in block
 	 * @returns {void}
 	 */
-	setParents(dependency, block, module) {
+	setParents(dependency, block, module, indexInBlock = -1) {
+		dependency._parentDependenciesBlockIndex = indexInBlock;
 		dependency._parentDependenciesBlock = block;
 		dependency._parentModule = module;
 	}
@@ -186,6 +172,14 @@ class ModuleGraph {
 		return dependency._parentDependenciesBlock;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {number} index
+	 */
+	getParentBlockIndex(dependency) {
+		return dependency._parentDependenciesBlockIndex;
+	}
+
 	/**
 	 * @param {Module} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency

package/lib/NormalModule.js

@@ -37,6 +37,7 @@ const {
 	keepOriginalOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
+const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
 const {
 	contextify,
@@ -186,7 +187,10 @@ makeSerializable(
  * @typedef {Object} NormalModuleCompilationHooks
  * @property {SyncHook<[object, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @property {SyncHook<[NormalModule]>} beforeParse
+ * @property {SyncHook<[NormalModule]>} beforeSnapshot
  * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
@@ -209,8 +213,30 @@ class NormalModule extends Module {
 			hooks = {
 				loader: new SyncHook(["loaderContext", "module"]),
 				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				readResourceForScheme: new HookMap(
-					() => new AsyncSeriesBailHook(["resource", "module"])
+				beforeParse: new SyncHook(["module"]),
+				beforeSnapshot: new SyncHook(["module"]),
+				// TODO webpack 6 deprecate
+				readResourceForScheme: new HookMap(scheme => {
+					const hook = hooks.readResource.for(scheme);
+					return createFakeHook(
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+							tap: (options, fn) =>
+								hook.tap(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								),
+							tapAsync: (options, fn) =>
+								hook.tapAsync(options, (loaderContext, callback) =>
+									fn(loaderContext.resource, loaderContext._module, callback)
+								),
+							tapPromise: (options, fn) =>
+								hook.tapPromise(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								)
+						})
+					);
+				}),
+				readResource: new HookMap(
+					() => new AsyncSeriesBailHook(["loaderContext"])
 				),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
@@ -365,6 +391,7 @@ class NormalModule extends Module {
 		this.generator = m.generator;
 		this.generatorOptions = m.generatorOptions;
 		this.resource = m.resource;
+		this.resourceResolveData = m.resourceResolveData;
 		this.context = m.context;
 		this.matchResource = m.matchResource;
 		this.loaders = m.loaders;
@@ -466,9 +493,10 @@ class NormalModule extends Module {
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
 	 * @returns {NormalModuleLoaderContext} loader context
 	 */
-	createLoaderContext(resolver, options, compilation, fs) {
+	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
 		const getCurrentLoaderName = () => {
 			const currentLoader = this.getCurrentLoader(loaderContext);
@@ -637,10 +665,7 @@ class NormalModule extends Module {
 
 		Object.assign(loaderContext, options.loader);
 
-		NormalModule.getCompilationHooks(compilation).loader.call(
-			loaderContext,
-			this
-		);
+		hooks.loader.call(loaderContext, this);
 
 		return loaderContext;
 	}
@@ -701,15 +726,17 @@ class NormalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
 	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	doBuild(options, compilation, resolver, fs, callback) {
-		const loaderContext = this.createLoaderContext(
+	_doBuild(options, compilation, resolver, fs, hooks, callback) {
+		const loaderContext = this._createLoaderContext(
 			resolver,
 			options,
 			compilation,
-			fs
+			fs,
+			hooks
 		);
 
 		const processResult = (err, result) => {
@@ -763,8 +790,6 @@ class NormalModule extends Module {
 			return callback();
 		};
 
-		const hooks = NormalModule.getCompilationHooks(compilation);
-
 		this.buildInfo.fileDependencies = new LazySet();
 		this.buildInfo.contextDependencies = new LazySet();
 		this.buildInfo.missingDependencies = new LazySet();
@@ -786,20 +811,15 @@ class NormalModule extends Module {
 				processResource: (loaderContext, resourcePath, callback) => {
 					const resource = loaderContext.resource;
 					const scheme = getScheme(resource);
-					if (scheme) {
-						hooks.readResourceForScheme
-							.for(scheme)
-							.callAsync(resource, this, (err, result) => {
-								if (err) return callback(err);
-								if (typeof result !== "string" && !result) {
-									return callback(new UnhandledSchemeError(scheme, resource));
-								}
-								return callback(null, result);
-							});
-					} else {
-						loaderContext.addDependency(resourcePath);
-						fs.readFile(resourcePath, callback);
-					}
+					hooks.readResource
+						.for(scheme)
+						.callAsync(loaderContext, (err, result) => {
+							if (err) return callback(err);
+							if (typeof result !== "string" && !result) {
+								return callback(new UnhandledSchemeError(scheme, resource));
+							}
+							return callback(null, result);
+						});
 				}
 			},
 			(err, result) => {
@@ -925,7 +945,9 @@ class NormalModule extends Module {
 
 		const startTime = compilation.compiler.fsStartTime || Date.now();
 
-		return this.doBuild(options, compilation, resolver, fs, err => {
+		const hooks = NormalModule.getCompilationHooks(compilation);
+
+		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
 			// if we have an error mark module as failed and exit
 			if (err) {
 				this.markModuleAsErrored(err);
@@ -957,6 +979,13 @@ class NormalModule extends Module {
 			};
 
 			const handleBuildDone = () => {
+				try {
+					hooks.beforeSnapshot.call(this);
+				} catch (err) {
+					this.markModuleAsErrored(err);
+					return callback();
+				}
+
 				const snapshotOptions = compilation.options.snapshot.module;
 				if (!this.buildInfo.cacheable || !snapshotOptions) {
 					return callback();
@@ -1021,6 +1050,14 @@ class NormalModule extends Module {
 				);
 			};
 
+			try {
+				hooks.beforeParse.call(this);
+			} catch (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
+			}
+
 			// check if this module should !not! be parsed.
 			// if so, exit here;
 			const noParseRule = options.module && options.module.noParse;