webpack 5.95.0 → 5.96.1

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

@@ -454,7 +454,7 @@ const visitModules = (
 
 	/** @type {Set<ChunkGroupInfo>} */
 	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<[ChunkGroupInfo, QueueItem]>} */
+	/** @type {Set<[ChunkGroupInfo, QueueItem | null]>} */
 	const chunkGroupsForMerging = new Set();
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
@@ -640,7 +640,7 @@ const visitModules = (
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
 			connectList.add([
-				cgi,
+				/** @type {ChunkGroupInfo} */ (cgi),
 				{
 					action: PROCESS_BLOCK,
 					block: b,

package/lib/cache/PackFileCacheStrategy.js

@@ -98,7 +98,7 @@ const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 class PackItemInfo {
 	/**
 	 * @param {string} identifier identifier of item
-	 * @param {string | null} etag etag of item
+	 * @param {string | null | undefined} etag etag of item
 	 * @param {any} value fresh value of item
 	 */
 	constructor(identifier, etag, value) {
@@ -268,20 +268,21 @@ class Pack {
 	}
 
 	_persistFreshContent() {
+		/** @typedef {{ items: Items, map: Map<string, any>, loc: number }} PackItem */
 		const itemsCount = this.freshContent.size;
 		if (itemsCount > 0) {
 			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
 			const itemsPerPack = Math.ceil(itemsCount / packCount);
+			/** @type {PackItem[]} */
 			const packs = [];
 			let i = 0;
 			let ignoreNextTimeTick = false;
 			const createNextPack = () => {
 				const loc = this._findLocation();
-				this.content[loc] = null; // reserve
+				this.content[loc] = /** @type {EXPECTED_ANY} */ (null); // reserve
+				/** @type {PackItem} */
 				const pack = {
-					/** @type {Items} */
 					items: new Set(),
-					/** @type {Map<string, any>} */
 					map: new Map(),
 					loc
 				};
@@ -407,7 +408,9 @@ class Pack {
 				await content.unpack(
 					"it should be merged with other small pack contents"
 				);
-				for (const [identifier, value] of content.content) {
+				for (const [identifier, value] of /** @type {Content} */ (
+					content.content
+				)) {
 					map.set(identifier, value);
 				}
 			});
@@ -423,7 +426,7 @@ class Pack {
 				mergedItems,
 				mergedUsedItems,
 				memoize(async () => {
-					/** @type {Map<string, any>} */
+					/** @type {Content} */
 					const map = new Map();
 					await Promise.all(addToMergedMap.map(fn => fn(map)));
 					return new PackContentItems(map);
@@ -471,7 +474,11 @@ class Pack {
 							);
 							const map = new Map();
 							for (const identifier of usedItems) {
-								map.set(identifier, content.content.get(identifier));
+								map.set(
+									identifier,
+									/** @type {Content} */
+									(content.content).get(identifier)
+								);
 							}
 							return new PackContentItems(map);
 						}
@@ -498,7 +505,11 @@ class Pack {
 							);
 							const map = new Map();
 							for (const identifier of unusedItems) {
-								map.set(identifier, content.content.get(identifier));
+								map.set(
+									identifier,
+									/** @type {Content} */
+									(content.content).get(identifier)
+								);
 							}
 							return new PackContentItems(map);
 						}
@@ -552,7 +563,11 @@ class Pack {
 							);
 							const map = new Map();
 							for (const identifier of items) {
-								map.set(identifier, content.content.get(identifier));
+								map.set(
+									identifier,
+									/** @type {Content} */
+									(content.content).get(identifier)
+								);
 							}
 							return new PackContentItems(map);
 						})
@@ -633,7 +648,8 @@ class Pack {
 					)
 				);
 				for (const identifier of items) {
-					this.itemInfo.get(identifier).location = idx;
+					/** @type {PackItemInfo} */
+					(this.itemInfo.get(identifier)).location = idx;
 				}
 			}
 			items = read();
@@ -643,9 +659,11 @@ class Pack {
 
 makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
+/** @typedef {Map<string, any>} Content */
+
 class PackContentItems {
 	/**
-	 * @param {Map<string, any>} map items
+	 * @param {Content} map items
 	 */
 	constructor(map) {
 		this.map = map;
@@ -680,12 +698,17 @@ class PackContentItems {
 					rollback(s);
 					if (err === NOT_SERIALIZABLE) continue;
 					const msg = "Skipped not serializable cache item";
-					if (err.message.includes("ModuleBuildError")) {
-						logger.log(`${msg} (in build error): ${err.message}`);
-						logger.debug(`${msg} '${key}' (in build error): ${err.stack}`);
+					const notSerializableErr = /** @type {Error} */ (err);
+					if (notSerializableErr.message.includes("ModuleBuildError")) {
+						logger.log(
+							`${msg} (in build error): ${notSerializableErr.message}`
+						);
+						logger.debug(
+							`${msg} '${key}' (in build error): ${notSerializableErr.stack}`
+						);
 					} else {
-						logger.warn(`${msg}: ${err.message}`);
-						logger.debug(`${msg} '${key}': ${err.stack}`);
+						logger.warn(`${msg}: ${notSerializableErr.message}`);
+						logger.debug(`${msg} '${key}': ${notSerializableErr.stack}`);
 					}
 				}
 			}
@@ -710,10 +733,11 @@ class PackContentItems {
 				} catch (err) {
 					rollback(s);
 					if (err === NOT_SERIALIZABLE) continue;
+					const notSerializableErr = /** @type {Error} */ (err);
 					logger.warn(
-						`Skipped not serializable cache item '${key}': ${err.message}`
+						`Skipped not serializable cache item '${key}': ${notSerializableErr.message}`
 					);
-					logger.debug(err.stack);
+					logger.debug(notSerializableErr.stack);
 				}
 			}
 			write(null);
@@ -767,6 +791,8 @@ makeSerializable(
 	"PackContentItems"
 );
 
+/** @typedef {(function(): Promise<PackContentItems> | PackContentItems)} LazyFn */
+
 class PackContent {
 	/*
 		This class can be in these states:
@@ -796,9 +822,9 @@ class PackContent {
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
 		this.items = items;
-		/** @type {(function(): Promise<PackContentItems> | PackContentItems) | undefined} */
+		/** @type {LazyFn | undefined} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
-		/** @type {Map<string, any> | undefined} */
+		/** @type {Content | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
 		this.outdated = false;
 		this.used = usedItems;
@@ -834,7 +860,7 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = this.lazy();
+		const value = /** @type {LazyFn} */ (this.lazy)();
 		if ("then" in value) {
 			return value.then(data => {
 				const map = data.map;
@@ -843,7 +869,10 @@ class PackContent {
 				}
 				// Move to state C
 				this.content = map;
-				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+				this.lazy = SerializerMiddleware.unMemoizeLazy(
+					/** @type {LazyFn} */
+					(this.lazy)
+				);
 				return map.get(identifier);
 			});
 		}
@@ -854,7 +883,10 @@ class PackContent {
 		}
 		// Move to state C
 		this.content = map;
-		this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+		this.lazy = SerializerMiddleware.unMemoizeLazy(
+			/** @type {LazyFn} */
+			(this.lazy)
+		);
 		return map.get(identifier);
 	}
 
@@ -944,7 +976,7 @@ class PackContent {
 		}
 		if (this.content) {
 			// State A2 or C2
-			/** @type {Map<string, any>} */
+			/** @type {Content} */
 			const map = new Map();
 			for (const item of this.items) {
 				map.set(item, this.content.get(item));
@@ -975,7 +1007,7 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = this.lazy();
+		const value = /** @type {LazyFn} */ (this.lazy)();
 		this.outdated = false;
 		if ("then" in value) {
 			// Move to state B1
@@ -985,14 +1017,17 @@ class PackContent {
 						logger.timeEnd(timeMessage);
 					}
 					const oldMap = data.map;
-					/** @type {Map<string, any>} */
+					/** @type {Content} */
 					const map = new Map();
 					for (const item of this.items) {
 						map.set(item, oldMap.get(item));
 					}
 					// Move to state C1 (or maybe C2)
 					this.content = map;
-					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+					this.lazy = SerializerMiddleware.unMemoizeLazy(
+						/** @type {LazyFn} */
+						(this.lazy)
+					);
 
 					return new PackContentItems(map);
 				})
@@ -1003,7 +1038,7 @@ class PackContent {
 				logger.timeEnd(timeMessage);
 			}
 			const oldMap = value.map;
-			/** @type {Map<string, any>} */
+			/** @type {Content} */
 			const map = new Map();
 			for (const item of this.items) {
 				map.set(item, oldMap.get(item));
@@ -1448,10 +1483,13 @@ class PackFileCacheStrategy {
 					const content = new PackContainer(
 						pack,
 						this.version,
-						/** @type {Snapshot} */ (this.buildSnapshot),
+						/** @type {Snapshot} */
+						(this.buildSnapshot),
 						updatedBuildDependencies,
-						this.resolveResults,
-						this.resolveBuildDependenciesSnapshot
+						/** @type {ResolveResults} */
+						(this.resolveResults),
+						/** @type {Snapshot} */
+						(this.resolveBuildDependenciesSnapshot)
 					);
 					return this.fileSerializer
 						.serialize(content, {