webpack 5.94.0 → 5.96.0

package/lib/asset/AssetSourceGenerator.js

@@ -8,50 +8,86 @@
 const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
+const {
+	NO_TYPES,
+	CSS_URL_TYPES,
+	JS_TYPES,
+	JS_AND_CSS_URL_TYPES
+} = require("../ModuleSourceTypesConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../NormalModule")} NormalModule */
 
-const TYPES = new Set(["javascript"]);
-
 class AssetSourceGenerator extends Generator {
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 */
+	constructor(moduleGraph) {
+		super();
+
+		this._moduleGraph = moduleGraph;
+	}
+
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(
 		module,
-		{ concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }
+		{ type, concatenationScope, getData, runtimeTemplate, runtimeRequirements }
 	) {
 		const originalSource = module.originalSource();
+		const data = getData ? getData() : undefined;
 
-		if (!originalSource) {
-			return new RawSource("");
-		}
+		switch (type) {
+			case "javascript": {
+				if (!originalSource) {
+					return new RawSource("");
+				}
+
+				const content = originalSource.source();
+				const encodedSource =
+					typeof content === "string" ? content : content.toString("utf-8");
 
-		const content = originalSource.source();
-		const encodedSource =
-			typeof content === "string" ? content : content.toString("utf-8");
-
-		let sourceContent;
-		if (concatenationScope) {
-			concatenationScope.registerNamespaceExport(
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			);
-			sourceContent = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			} = ${JSON.stringify(encodedSource)};`;
-		} else {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(
-				encodedSource
-			)};`;
+				let sourceContent;
+				if (concatenationScope) {
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+					sourceContent = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					} = ${JSON.stringify(encodedSource)};`;
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.module);
+					sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(
+						encodedSource
+					)};`;
+				}
+				return new RawSource(sourceContent);
+			}
+			case "css-url": {
+				if (!originalSource) {
+					return null;
+				}
+
+				const content = originalSource.source();
+				const encodedSource =
+					typeof content === "string" ? content : content.toString("utf-8");
+
+				if (data) {
+					data.set("url", { [type]: encodedSource });
+				}
+				return null;
+			}
+			default:
+				return null;
 		}
-		return new RawSource(sourceContent);
 	}
 
 	/**
@@ -65,10 +101,29 @@ class AssetSourceGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		const sourceTypes = new Set();
+		const connections = this._moduleGraph.getIncomingConnections(module);
+
+		for (const connection of connections) {
+			if (!connection.originModule) {
+				continue;
+			}
+
+			sourceTypes.add(connection.originModule.type.split("/")[0]);
+		}
+
+		if (sourceTypes.has("javascript") && sourceTypes.has("css")) {
+			return JS_AND_CSS_URL_TYPES;
+		} else if (sourceTypes.has("javascript")) {
+			return JS_TYPES;
+		} else if (sourceTypes.has("css")) {
+			return CSS_URL_TYPES;
+		}
+
+		return NO_TYPES;
 	}
 
 	/**

package/lib/asset/RawDataUrlModule.js

@@ -7,6 +7,7 @@
 
 const { RawSource } = require("webpack-sources");
 const Module = require("../Module");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const { ASSET_MODULE_TYPE_RAW_DATA_URL } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
@@ -26,8 +27,6 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-const TYPES = new Set(["javascript"]);
-
 class RawDataUrlModule extends Module {
 	/**
 	 * @param {string} url raw url
@@ -46,7 +45,7 @@ class RawDataUrlModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**
@@ -114,7 +113,9 @@ class RawDataUrlModule extends Module {
 			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
 		);
 		const data = new Map();
-		data.set("url", this.urlBuffer);
+		data.set("url", {
+			javascript: this.url
+		});
 		const runtimeRequirements = new Set();
 		runtimeRequirements.add(RuntimeGlobals.module);
 		return { sources, runtimeRequirements, data };

package/lib/buildChunkGraph.js

@@ -38,6 +38,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
+ * @property {boolean} initialized is this chunk group initialized
  * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
  * @property {bigint[]} 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)
@@ -345,8 +346,8 @@ const visitModules = (
 	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
 	const blockChunkGroups = new Map();
 
-	/** @type {Map<ChunkGroupInfo, DependenciesBlock>} */
-	const blockByChunkGroups = new Map();
+	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
+	const blocksByChunkGroups = new Map();
 
 	/** @type {Map<string, ChunkGroupInfo>} */
 	const namedChunkGroups = new Map();
@@ -367,7 +368,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
+	/** @type {Map<ChunkGroupInfo, Set<[ChunkGroupInfo, QueueItem | null]>>} */
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
@@ -382,6 +383,7 @@ const visitModules = (
 		);
 		/** @type {ChunkGroupInfo} */
 		const chunkGroupInfo = {
+			initialized: false,
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
@@ -452,7 +454,7 @@ const visitModules = (
 
 	/** @type {Set<ChunkGroupInfo>} */
 	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<ChunkGroupInfo>} */
+	/** @type {Set<[ChunkGroupInfo, QueueItem | null]>} */
 	const chunkGroupsForMerging = new Set();
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
@@ -505,6 +507,7 @@ const visitModules = (
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: entrypoint,
+						initialized: false,
 						runtime: entrypoint.options.runtime || entrypoint.name,
 						minAvailableModules: ZERO_BIGINT,
 						availableModulesToBeMerged: [],
@@ -572,6 +575,7 @@ const visitModules = (
 					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
 					cgi = {
+						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
@@ -614,7 +618,6 @@ const visitModules = (
 				blockConnections.set(b, []);
 			}
 			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
-			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -636,19 +639,17 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
-
-			// TODO check if this really need to be done for each traversal
-			// or if it is enough when it's queued when created
-			// 4. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module,
-				chunk: c.chunks[0],
-				chunkGroup: c,
-				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
-			});
+			connectList.add([
+				/** @type {ChunkGroupInfo} */ (cgi),
+				{
+					action: PROCESS_BLOCK,
+					block: b,
+					module,
+					chunk: c.chunks[0],
+					chunkGroup: c,
+					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
+				}
+			]);
 		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
@@ -901,11 +902,10 @@ const visitModules = (
 		for (const [chunkGroupInfo, targets] of queueConnect) {
 			// 1. Add new targets to the list of children
 			if (chunkGroupInfo.children === undefined) {
-				chunkGroupInfo.children = targets;
-			} else {
-				for (const target of targets) {
-					chunkGroupInfo.children.add(target);
-				}
+				chunkGroupInfo.children = new Set();
+			}
+			for (const [target] of targets) {
+				chunkGroupInfo.children.add(target);
 			}
 
 			// 2. Calculate resulting available modules
@@ -915,9 +915,9 @@ const visitModules = (
 			const runtime = chunkGroupInfo.runtime;
 
 			// 3. Update chunk group info
-			for (const target of targets) {
+			for (const [target, processBlock] of targets) {
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add(target);
+				chunkGroupsForMerging.add([target, processBlock]);
 				const oldRuntime = target.runtime;
 				const newRuntime = mergeRuntime(oldRuntime, runtime);
 				if (oldRuntime !== newRuntime) {
@@ -935,7 +935,7 @@ const visitModules = (
 		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
 		// Execute the merge
-		for (const info of chunkGroupsForMerging) {
+		for (const [info, processBlock] of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
 			const cachedMinAvailableModules = info.minAvailableModules;
 			let minAvailableModules = cachedMinAvailableModules;
@@ -958,6 +958,27 @@ const visitModules = (
 				info.resultingAvailableModules = undefined;
 				outdatedChunkGroupInfo.add(info);
 			}
+
+			if (processBlock) {
+				let blocks = blocksByChunkGroups.get(info);
+				if (!blocks) {
+					blocksByChunkGroups.set(info, (blocks = new Set()));
+				}
+
+				// Whether to walk block depends on minAvailableModules and input block.
+				// We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules
+				// If input is the same, we can skip re-walk
+				let needWalkBlock = !info.initialized || changed;
+				if (!blocks.has(processBlock.block)) {
+					needWalkBlock = true;
+					blocks.add(processBlock.block);
+				}
+
+				if (needWalkBlock) {
+					info.initialized = true;
+					queueDelayed.push(processBlock);
+				}
+			}
 		}
 		chunkGroupsForMerging.clear();
 	};
@@ -1057,7 +1078,7 @@ const visitModules = (
 						connectList = new Set();
 						queueConnect.set(info, connectList);
 					}
-					connectList.add(cgi);
+					connectList.add([cgi, null]);
 				}
 			}
 
@@ -1117,48 +1138,44 @@ const visitModules = (
 	for (const info of outdatedOrderIndexChunkGroups) {
 		const { chunkGroup, runtime } = info;
 
-		const block = blockByChunkGroups.get(info);
+		const blocks = blocksByChunkGroups.get(info);
 
-		if (!block) {
+		if (!blocks) {
 			continue;
 		}
 
-		let preOrderIndex = 0;
-		let postOrderIndex = 0;
-
-		/**
-		 * @param {DependenciesBlock} current current
-		 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
-		 */
-		const process = (current, visited) => {
-			const blockModules = getBlockModules(current, runtime);
-			if (blockModules === undefined) {
-				return;
-			}
-
-			for (let i = 0, len = blockModules.length; i < len; i += 3) {
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				if (activeState === false) {
-					continue;
-				}
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (visited.has(refModule)) {
-					continue;
-				}
+		for (const block of blocks) {
+			let preOrderIndex = 0;
+			let postOrderIndex = 0;
+			/**
+			 * @param {DependenciesBlock} current current
+			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
+			 */
+			const process = (current, visited) => {
+				const blockModules = getBlockModules(current, runtime);
+				for (let i = 0, len = blockModules.length; i < len; i += 3) {
+					const activeState = /** @type {ConnectionState} */ (
+						blockModules[i + 1]
+					);
+					if (activeState === false) {
+						continue;
+					}
+					const refModule = /** @type {Module} */ (blockModules[i]);
+					if (visited.has(refModule)) {
+						continue;
+					}
 
-				visited.add(refModule);
+					visited.add(refModule);
 
-				if (refModule) {
-					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
-					process(refModule, visited);
-					chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					if (refModule) {
+						chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
+						process(refModule, visited);
+						chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					}
 				}
-			}
-		};
-
-		process(block, new Set());
+			};
+			process(block, new Set());
+		}
 	}
 	outdatedOrderIndexChunkGroups.clear();
 	ordinalByModule.clear();