webpack 5.57.1 → 5.58.0

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/buildChunkGraph.js

@@ -43,7 +43,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
- * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
  * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
  * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
@@ -70,97 +70,106 @@ const bySetSize = (a, b) => {
 	return b.size + b.plus.size - a.size - a.plus.size;
 };
 
-/**
- *
- * @param {ModuleGraphConnection[]} connections list of connections
- * @param {RuntimeSpec} runtime for which runtime
- * @returns {ConnectionState} connection state
- */
-const getActiveStateOfConnections = (connections, runtime) => {
-	let merged = connections[0].getActiveState(runtime);
-	if (merged === true) return true;
-	for (let i = 1; i < connections.length; i++) {
-		const c = connections[i];
-		merged = ModuleGraphConnection.addConnectionStates(
-			merged,
-			c.getActiveState(runtime)
-		);
-		if (merged === true) return true;
+const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	let blockCache;
+	let modules;
+
+	const arrays = [];
+
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = queue.pop();
+		const arr = [];
+		arrays.push(arr);
+		blockModulesMap.set(block, arr);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
 	}
-	return merged;
-};
 
-/**
- * Extracts block to modules mapping from all modules
- * @param {Compilation} compilation the compilation
- * @returns {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} the mapping block to modules
- */
-const extractBlockModulesMap = compilation => {
-	const { moduleGraph } = compilation;
-
-	/** @type {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} */
-	const blockModulesMap = new Map();
-
-	const blockQueue = new Set();
-
-	for (const module of compilation.modules) {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
-		let moduleMap;
-
-		for (const connection of moduleGraph.getOutgoingConnections(module)) {
-			const d = connection.dependency;
-			// We skip connections without dependency
-			if (!d) continue;
-			const m = connection.module;
-			// We skip connections without Module pointer
-			if (!m) continue;
-			// We skip weak connections
-			if (connection.weak) continue;
-			const state = connection.getActiveState(undefined);
-			// We skip inactive connections
-			if (state === false) continue;
-			// Store Dependency to Module mapping in local map
-			// to allow to access it faster compared to
-			// moduleGraph.getConnection()
-			if (moduleMap === undefined) {
-				moduleMap = new WeakMap();
-			}
-			moduleMap.set(connection.dependency, connection);
+	for (const connection of moduleGraph.getOutgoingConnections(module)) {
+		const d = connection.dependency;
+		// We skip connections without dependency
+		if (!d) continue;
+		const m = connection.module;
+		// We skip connections without Module pointer
+		if (!m) continue;
+		// We skip weak connections
+		if (connection.weak) continue;
+		const state = connection.getActiveState(runtime);
+		// We skip inactive connections
+		if (state === false) continue;
+
+		const block = moduleGraph.getParentBlock(d);
+		let index = moduleGraph.getParentBlockIndex(d);
+
+		// deprecated fallback
+		if (index < 0) {
+			index = block.dependencies.indexOf(d);
 		}
 
-		blockQueue.clear();
-		blockQueue.add(module);
-		for (const block of blockQueue) {
-			let modules;
-
-			if (moduleMap !== undefined && block.dependencies) {
-				for (const dep of block.dependencies) {
-					const connection = moduleMap.get(dep);
-					if (connection !== undefined) {
-						const { module } = connection;
-						if (modules === undefined) {
-							modules = new Map();
-							blockModulesMap.set(block, modules);
-						}
-						const old = modules.get(module);
-						if (old !== undefined) {
-							old.push(connection);
-						} else {
-							modules.set(module, [connection]);
-						}
+		if (blockCache !== block) {
+			modules = blockModulesMap.get((blockCache = block));
+		}
+
+		const i = index << 2;
+		modules[i] = m;
+		modules[i + 1] = state;
+	}
+
+	for (const modules of arrays) {
+		if (modules.length === 0) continue;
+		let indexMap;
+		let length = 0;
+		outer: for (let j = 0; j < modules.length; j += 2) {
+			const m = modules[j];
+			if (m === undefined) continue;
+			const state = modules[j + 1];
+			if (indexMap === undefined) {
+				let i = 0;
+				for (; i < length; i += 2) {
+					if (modules[i] === m) {
+						const merged = modules[i + 1];
+						if (merged === true) continue outer;
+						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
+							merged,
+							state
+						);
 					}
 				}
-			}
-
-			if (block.blocks) {
-				for (const b of block.blocks) {
-					blockQueue.add(b);
+				modules[length] = m;
+				length++;
+				modules[length] = state;
+				length++;
+				if (length > 30) {
+					// To avoid worse case performance, we will use an index map for
+					// linear cost access, which allows to maintain O(n) complexity
+					// while keeping allocations down to a minimum
+					indexMap = new Map();
+					for (let i = 0; i < length; i += 2) {
+						indexMap.set(modules[i], i + 1);
+					}
+				}
+			} else {
+				const idx = indexMap.get(m);
+				if (idx !== undefined) {
+					const merged = modules[idx];
+					if (merged === true) continue outer;
+					modules[idx] = ModuleGraphConnection.addConnectionStates(
+						merged,
+						state
+					);
+				} else {
+					modules[length] = m;
+					length++;
+					modules[length] = state;
+					indexMap.set(m, length);
+					length++;
 				}
 			}
 		}
+		modules.length = length;
 	}
-
-	return blockModulesMap;
 };
 
 /**
@@ -182,10 +191,55 @@ const visitModules = (
 	blocksWithNestedBlocks,
 	allCreatedChunkGroups
 ) => {
-	const { moduleGraph, chunkGraph } = compilation;
+	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
-	logger.time("visitModules: prepare");
-	const blockModulesMap = extractBlockModulesMap(compilation);
+	const blockModulesRuntimeMap = new Map();
+
+	/** @type {RuntimeSpec | false} */
+	let blockModulesMapRuntime = false;
+	let blockModulesMap;
+
+	/**
+	 *
+	 * @param {DependenciesBlock} block block
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 */
+	const getBlockModules = (block, runtime) => {
+		if (blockModulesMapRuntime !== runtime) {
+			blockModulesMap = blockModulesRuntimeMap.get(runtime);
+			if (blockModulesMap === undefined) {
+				blockModulesMap = new Map();
+				blockModulesRuntimeMap.set(runtime, blockModulesMap);
+			}
+		}
+		let blockModules = blockModulesMap.get(block);
+		if (blockModules !== undefined) return blockModules;
+		const module = /** @type {Module} */ (block.getRootBlock());
+		const memCache = moduleMemCaches && moduleMemCaches.get(module);
+		if (memCache !== undefined) {
+			const map = memCache.provide(
+				"bundleChunkGraph.blockModules",
+				runtime,
+				() => {
+					logger.time("visitModules: prepare");
+					const map = new Map();
+					extractBlockModules(module, moduleGraph, runtime, map);
+					logger.timeAggregate("visitModules: prepare");
+					return map;
+				}
+			);
+			for (const [block, blockModules] of map)
+				blockModulesMap.set(block, blockModules);
+			return map.get(block);
+		} else {
+			logger.time("visitModules: prepare");
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			blockModules = blockModulesMap.get(block);
+			logger.timeAggregate("visitModules: prepare");
+			return blockModules;
+		}
+	};
 
 	let statProcessedQueueItems = 0;
 	let statProcessedBlocks = 0;
@@ -308,9 +362,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	logger.timeEnd("visitModules: prepare");
-
-	/** @type {[Module, ModuleGraphConnection[]][]} */
+	/** @type {[Module, ConnectionState][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -478,21 +530,23 @@ const visitModules = (
 	const processBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules, runtime } = chunkGroupInfo;
+			const { minAvailableModules } = chunkGroupInfo;
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
-			for (const entry of blockModules) {
-				const [refModule, connections] = entry;
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
 				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
 					// skip early if already connected
 					continue;
 				}
-				const activeState = getActiveStateOfConnections(connections, runtime);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				if (activeState !== true) {
-					skipConnectionBuffer.push(entry);
+					skipConnectionBuffer.push([refModule, activeState]);
 					if (activeState === false) continue;
 				}
 				if (
@@ -562,12 +616,15 @@ const visitModules = (
 	const processEntryBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
 			// Traverse all referenced modules
-			for (const [refModule, connections] of blockModules) {
-				const activeState = getActiveStateOfConnections(connections, undefined);
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				// enqueue, then add and enter to be in the correct order
 				// this is relevant with circular dependencies
 				queueBuffer.push({
@@ -1059,10 +1116,9 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules, runtime } = info;
+				const { minAvailableModules } = info;
 				for (const entry of info.skippedModuleConnections) {
-					const [module, connections] = entry;
-					const activeState = getActiveStateOfConnections(connections, runtime);
+					const [module, activeState] = entry;
 					if (activeState === false) continue;
 					if (activeState === true) {
 						info.skippedModuleConnections.delete(entry);
@@ -1114,6 +1170,7 @@ const visitModules = (
 	while (queue.length || queueConnect.size) {
 		logger.time("visitModules: visiting");
 		processQueue();
+		logger.timeAggregateEnd("visitModules: prepare");
 		logger.timeEnd("visitModules: visiting");
 
 		if (chunkGroupsForCombining.size > 0) {

package/lib/logging/Logger.js

@@ -155,6 +155,7 @@ class WebpackLogger {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
 		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }

package/lib/node/NodeTargetPlugin.js

@@ -19,6 +19,7 @@ const builtins = [
 	"constants",
 	"crypto",
 	"dgram",
+	"diagnostics_channel",
 	"dns",
 	"dns/promises",
 	"domain",

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -30,6 +30,7 @@ class EnsureChunkConditionsPlugin {
 					/** @type {Set<ChunkGroup>} */
 					const chunkGroups = new Set();
 					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							if (!module.chunkCondition(chunk, compilation)) {
 								sourceChunks.add(chunk);