webpack 5.56.1 → 5.58.1

package/lib/ModuleGraph.js

@@ -29,7 +29,7 @@ const EMPTY_SET = new Set();
 
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} mapped by origin module
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
  */
 const getConnectionsByOriginModule = set => {
 	const map = new Map();
@@ -57,11 +57,41 @@ const getConnectionsByOriginModule = set => {
 	return map;
 };
 
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
+ */
+const getConnectionsByModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { module } = connection;
+		if (lastModule === module) {
+			lastList.push(connection);
+		} else {
+			lastModule = module;
+			const list = map.get(module);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(module, list);
+			}
+		}
+	}
+	return map;
+};
+
 class ModuleGraphModule {
 	constructor() {
 		/** @type {SortableSet<ModuleGraphConnection>} */
 		this.incomingConnections = new SortableSet();
-		/** @type {Set<ModuleGraphConnection> | undefined} */
+		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
 		this.outgoingConnections = undefined;
 		/** @type {Module | null} */
 		this.issuer = undefined;
@@ -93,18 +123,10 @@ 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;
 
-		/** @type {WeakMap<Module, WeakTupleMap<any, any>>} */
+		/** @type {Map<Module, WeakTupleMap<any, any>>} */
 		this._moduleMemCaches = undefined;
 	}
 
@@ -113,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;
 	}
 
@@ -133,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;
 	}
@@ -156,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
@@ -180,7 +204,7 @@ class ModuleGraph {
 			}
 			mgm._unassignedConnections.push(connection);
 			if (mgm.outgoingConnections === undefined) {
-				mgm.outgoingConnections = new Set();
+				mgm.outgoingConnections = new SortableSet();
 			}
 			mgm.outgoingConnections.add(connection);
 		} else {
@@ -282,7 +306,7 @@ class ModuleGraph {
 		const oldConnections = oldMgm.outgoingConnections;
 		if (oldConnections !== undefined) {
 			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new Set();
+				newMgm.outgoingConnections = new SortableSet();
 			}
 			const newConnections = newMgm.outgoingConnections;
 			for (const connection of oldConnections) {
@@ -319,7 +343,7 @@ class ModuleGraph {
 		const oldConnections = oldMgm.outgoingConnections;
 		if (oldConnections !== undefined) {
 			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new Set();
+				newMgm.outgoingConnections = new SortableSet();
 			}
 			const newConnections = newMgm.outgoingConnections;
 			for (const connection of oldConnections) {
@@ -434,13 +458,24 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 */
+	getOutgoingConnectionsByModule(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined
+			? undefined
+			: connections.getFromUnorderedCache(getConnectionsByModule);
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @returns {ModuleProfile | null} the module profile
@@ -728,7 +763,7 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {WeakMap<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
 	 */
 	setModuleMemCaches(moduleMemCaches) {
 		this._moduleMemCaches = moduleMemCaches;

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,
@@ -187,6 +188,7 @@ makeSerializable(
  * @property {SyncHook<[object, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
  * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
@@ -209,8 +211,28 @@ class NormalModule extends Module {
 			hooks = {
 				loader: new SyncHook(["loaderContext", "module"]),
 				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				readResourceForScheme: new HookMap(
-					() => new AsyncSeriesBailHook(["resource", "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"])
 			};
@@ -786,20 +808,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) => {

package/lib/NormalModuleFactory.js

@@ -466,49 +466,68 @@ class NormalModuleFactory extends ModuleFactory {
 							: "") +
 						stringifyLoadersAndResource(loaders, resourceData.resource);
 
-					const resourceDataForRules = matchResourceData || resourceData;
-					const result = this.ruleSet.exec({
-						resource: resourceDataForRules.path,
-						realResource: resourceData.path,
-						resourceQuery: resourceDataForRules.query,
-						resourceFragment: resourceDataForRules.fragment,
-						scheme,
-						assertions,
-						mimetype: matchResourceData ? "" : resourceData.data.mimetype || "",
-						dependency: dependencyType,
-						descriptionData: matchResourceData
-							? undefined
-							: resourceData.data.descriptionFileData,
-						issuer: contextInfo.issuer,
-						compiler: contextInfo.compiler,
-						issuerLayer: contextInfo.issuerLayer || ""
-					});
 					const settings = {};
 					const useLoadersPost = [];
 					const useLoaders = [];
 					const useLoadersPre = [];
-					for (const r of result) {
-						if (r.type === "use") {
-							if (!noAutoLoaders && !noPrePostAutoLoaders) {
-								useLoaders.push(r.value);
-							}
-						} else if (r.type === "use-post") {
-							if (!noPrePostAutoLoaders) {
-								useLoadersPost.push(r.value);
-							}
-						} else if (r.type === "use-pre") {
-							if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
-								useLoadersPre.push(r.value);
+
+					// handle .webpack[] suffix
+					let resource;
+					let match;
+					if (
+						matchResourceData &&
+						typeof (resource = matchResourceData.resource) === "string" &&
+						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
+					) {
+						settings.type = match[1];
+						matchResourceData.resource = matchResourceData.resource.slice(
+							0,
+							-settings.type.length - 10
+						);
+					} else {
+						settings.type = "javascript/auto";
+						const resourceDataForRules = matchResourceData || resourceData;
+						const result = this.ruleSet.exec({
+							resource: resourceDataForRules.path,
+							realResource: resourceData.path,
+							resourceQuery: resourceDataForRules.query,
+							resourceFragment: resourceDataForRules.fragment,
+							scheme,
+							assertions,
+							mimetype: matchResourceData
+								? ""
+								: resourceData.data.mimetype || "",
+							dependency: dependencyType,
+							descriptionData: matchResourceData
+								? undefined
+								: resourceData.data.descriptionFileData,
+							issuer: contextInfo.issuer,
+							compiler: contextInfo.compiler,
+							issuerLayer: contextInfo.issuerLayer || ""
+						});
+						for (const r of result) {
+							if (r.type === "use") {
+								if (!noAutoLoaders && !noPrePostAutoLoaders) {
+									useLoaders.push(r.value);
+								}
+							} else if (r.type === "use-post") {
+								if (!noPrePostAutoLoaders) {
+									useLoadersPost.push(r.value);
+								}
+							} else if (r.type === "use-pre") {
+								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
+									useLoadersPre.push(r.value);
+								}
+							} else if (
+								typeof r.value === "object" &&
+								r.value !== null &&
+								typeof settings[r.type] === "object" &&
+								settings[r.type] !== null
+							) {
+								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
+							} else {
+								settings[r.type] = r.value;
 							}
-						} else if (
-							typeof r.value === "object" &&
-							r.value !== null &&
-							typeof settings[r.type] === "object" &&
-							settings[r.type] !== null
-						) {
-							settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
-						} else {
-							settings[r.type] = r.value;
 						}
 					}
 
@@ -528,23 +547,6 @@ class NormalModuleFactory extends ModuleFactory {
 						}
 						for (const loader of preLoaders) allLoaders.push(loader);
 						let type = settings.type;
-						if (!type) {
-							let resource;
-							let match;
-							if (
-								matchResourceData &&
-								typeof (resource = matchResourceData.resource) === "string" &&
-								(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
-							) {
-								type = match[1];
-								matchResourceData.resource = matchResourceData.resource.slice(
-									0,
-									-type.length - 10
-								);
-							} else {
-								type = "javascript/auto";
-							}
-						}
 						const resolveOptions = settings.resolve;
 						const layer = settings.layer;
 						if (layer !== undefined && !layers) {

package/lib/WebpackOptionsApply.js

@@ -550,7 +550,7 @@ class WebpackOptionsApply extends OptionsApply {
 								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
 							);
 						}
-						compiler.moduleMemCaches = new WeakMap();
+						compiler.moduleMemCaches = new Map();
 					}
 					break;
 				}
@@ -577,7 +577,7 @@ class WebpackOptionsApply extends OptionsApply {
 								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
 							);
 						}
-						compiler.moduleMemCaches = new WeakMap();
+						compiler.moduleMemCaches = new Map();
 					}
 					switch (cacheOptions.store) {
 						case "pack": {