webpack 5.104.1 → 5.105.0

package/lib/asset/RawDataUrlModule.js

@@ -22,8 +22,10 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -114,11 +116,13 @@ class RawDataUrlModule extends Module {
 		if (this.url === undefined) {
 			this.url = /** @type {Buffer} */ (this.urlBuffer).toString();
 		}
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set(
 			JAVASCRIPT_TYPE,
 			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
 		);
+		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		data.set("url", {
 			javascript: this.url

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -12,12 +12,14 @@ const Template = require("../Template");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
+/** @typedef {Map<string, string>} Dependencies */
+
 /**
  * @extends {InitFragment<GenerateContext>}
  */
 class AwaitDependenciesInitFragment extends InitFragment {
 	/**
-	 * @param {Map<string, string>} dependencies maps an import var to an async module that needs to be awaited
+	 * @param {Dependencies} dependencies maps an import var to an async module that needs to be awaited
 	 */
 	constructor(dependencies) {
 		super(
@@ -26,6 +28,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			0,
 			"await-dependencies"
 		);
+		/** @type {Dependencies} */
 		this.dependencies = dependencies;
 	}
 

package/lib/buildChunkGraph.js

@@ -50,6 +50,8 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {number} postOrderIndex next post order index
  * @property {boolean} chunkLoading has a chunk loading mechanism
  * @property {boolean} asyncChunks create async chunks
+ * @property {Module | null} depModule the module that is the dependency of the block
+ * @property {boolean} circular Whether to deduplicate to avoid circular references
  */
 
 /**
@@ -165,6 +167,7 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 
 	for (const modules of arrays) {
 		if (modules.length === 0) continue;
+		/** @type {undefined | Map<Module | ModuleGraphConnection | ConnectionState, number>} */
 		let indexMap;
 		let length = 0;
 		outer: for (let j = 0; j < modules.length; j += 3) {
@@ -360,6 +363,9 @@ const visitModules = (
 	/** @type {NamedChunkGroup} */
 	const namedAsyncEntrypoints = new Map();
 
+	/** @type {Map<Module, ChunkGroupInfo>} */
+	const depModuleAsyncEntrypoints = new Map();
+
 	/** @type {Set<ChunkGroupInfo>} */
 	const outdatedOrderIndexChunkGroups = new Set();
 
@@ -373,7 +379,8 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<[ChunkGroupInfo, QueueItem | null]>>} */
+	/** @typedef {Set<[ChunkGroupInfo, QueueItem | null]>} ConnectList */
+	/** @type {Map<ChunkGroupInfo, ConnectList>} */
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
@@ -388,6 +395,8 @@ const visitModules = (
 		);
 		/** @type {ChunkGroupInfo} */
 		const chunkGroupInfo = {
+			depModule: null,
+			circular: false,
 			initialized: false,
 			chunkGroup,
 			runtime,
@@ -496,11 +505,16 @@ const visitModules = (
 		let c;
 		/** @type {Entrypoint | undefined} */
 		let entrypoint;
+		/** @type {Module | null} */
+		const depModule = moduleGraph.getModule(b.dependencies[0]);
 		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
 		if (cgi === undefined) {
 			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
 			if (entryOptions) {
 				cgi = namedAsyncEntrypoints.get(/** @type {string} */ (chunkName));
+				if (!cgi && !b.circular && depModule) {
+					cgi = depModuleAsyncEntrypoints.get(depModule);
+				}
 				if (!cgi) {
 					entrypoint = compilation.addAsyncEntrypoint(
 						entryOptions,
@@ -511,6 +525,8 @@ const visitModules = (
 					maskByChunk.set(entrypoint.chunks[0], ZERO_BIGINT);
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
+						depModule,
+						circular: b.circular,
 						chunkGroup: entrypoint,
 						initialized: false,
 						runtime:
@@ -548,6 +564,12 @@ const visitModules = (
 							(cgi)
 						);
 					}
+					if (!b.circular && depModule) {
+						depModuleAsyncEntrypoints.set(
+							depModule,
+							/** @type {ChunkGroupInfo} */ (cgi)
+						);
+					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 					// TODO merge entryOptions
@@ -590,6 +612,8 @@ const visitModules = (
 					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
 					cgi = {
+						depModule,
+						circular: b.circular,
 						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
@@ -651,6 +675,7 @@ const visitModules = (
 			// 3. We enqueue the chunk group info creation/updating
 			let connectList = queueConnect.get(chunkGroupInfo);
 			if (connectList === undefined) {
+				/** @type {ConnectList} */
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
@@ -665,7 +690,10 @@ const visitModules = (
 					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
 				}
 			]);
-		} else if (entrypoint !== undefined) {
+		} else if (
+			entrypoint !== undefined &&
+			(chunkGroupInfo.circular || chunkGroupInfo.depModule !== depModule)
+		) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
 	};
@@ -1091,6 +1119,7 @@ const visitModules = (
 				for (const cgi of info.children) {
 					let connectList = queueConnect.get(info);
 					if (connectList === undefined) {
+						/** @type {ConnectList} */
 						connectList = new Set();
 						queueConnect.set(info, connectList);
 					}

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -43,6 +43,7 @@ class MemoryWithGcCachePlugin {
 		compiler.hooks.afterDone.tap(PLUGIN_NAME, () => {
 			generation++;
 			let clearedEntries = 0;
+			/** @type {undefined | string} */
 			let lastClearedIdentifier;
 			// Avoid coverage problems due indirect changes
 			/* istanbul ignore next */

package/lib/cache/PackFileCacheStrategy.js

@@ -28,7 +28,7 @@ const {
 /** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 /** @typedef {Set<string>} Items */
@@ -134,13 +134,17 @@ class Pack {
 		this.itemInfo = new Map();
 		/** @type {(string | undefined)[]} */
 		this.requests = [];
+		/** @type {undefined | NodeJS.Timeout} */
 		this.requestsTimeout = undefined;
 		/** @type {ItemInfo} */
 		this.freshContent = new Map();
 		/** @type {(undefined | PackContent)[]} */
 		this.content = [];
+		/** @type {boolean} */
 		this.invalid = false;
+		/** @type {Logger} */
 		this.logger = logger;
+		/** @type {number} */
 		this.maxAge = maxAge;
 	}
 
@@ -243,6 +247,7 @@ class Pack {
 	 * @returns {number} new location of data entries
 	 */
 	_findLocation() {
+		/** @type {number} */
 		let i;
 		for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
 		return i;
@@ -256,6 +261,7 @@ class Pack {
 	 */
 	_gcAndUpdateLocation(items, usedItems, newLoc) {
 		let count = 0;
+		/** @type {undefined | string} */
 		let lastGC;
 		const now = Date.now();
 		for (const identifier of items) {
@@ -381,6 +387,7 @@ class Pack {
 		}
 
 		// 2. Check if minimum number is reached
+		/** @type {number[]} */
 		let mergedIndices;
 		if (
 			smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
@@ -505,6 +512,7 @@ class Pack {
 
 				// 5. Determine items for the unused content file
 				const unusedItems = new Set(content.items);
+				/** @type {Items} */
 				const usedOfUnusedItems = new Set();
 				for (const identifier of usedItems) {
 					unusedItems.delete(identifier);
@@ -521,6 +529,7 @@ class Pack {
 							await content.unpack(
 								"it should be splitted into used and unused items"
 							);
+							/** @type {Content} */
 							const map = new Map();
 							for (const identifier of unusedItems) {
 								map.set(
@@ -579,6 +588,7 @@ class Pack {
 							await content.unpack(
 								"it contains old items that should be garbage collected"
 							);
+							/** @type {Content} */
 							const map = new Map();
 							for (const identifier of items) {
 								map.set(
@@ -691,7 +701,7 @@ class PackContentItems {
 	}
 
 	/**
-	 * @param {ObjectSerializerContext & { logger: Logger, profile: boolean | undefined  }} context context
+	 * @param {ObjectSerializerContext & { logger: Logger, profile: boolean | undefined }} context context
 	 */
 	serialize({ write, snapshot, rollback, logger, profile }) {
 		if (profile) {
@@ -774,6 +784,7 @@ class PackContentItems {
 		if (read()) {
 			this.map = read();
 		} else if (profile) {
+			/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */
 			const map = new Map();
 			let key = read();
 			while (key !== null) {
@@ -799,6 +810,7 @@ class PackContentItems {
 			}
 			this.map = map;
 		} else {
+			/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */
 			const map = new Map();
 			let key = read();
 			while (key !== null) {
@@ -816,7 +828,7 @@ makeSerializable(
 	"PackContentItems"
 );
 
-/** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number }}>} LazyFunction */
+/** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number } }>} LazyFunction */
 
 class PackContent {
 	/*
@@ -846,14 +858,19 @@ class PackContent {
 	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
+		/** @type {Items} */
 		this.items = items;
 		/** @type {LazyFunction | undefined} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
 		/** @type {Content | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
+		/** @type {boolean} */
 		this.outdated = false;
+		/** @type {Items} */
 		this.used = usedItems;
+		/** @type {Logger | undefined} */
 		this.logger = logger;
+		/** @type {string | undefined} */
 		this.lazyName = lazyName;
 	}
 
@@ -1091,10 +1108,10 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
-	 * @param {boolean | undefined} options.profile track and log detailed timing information for individual cache items
-	 * @param {boolean | undefined} options.allowCollectingMemory allow to collect unused memory created during deserialization
-	 * @param {false | "gzip" | "brotli" | undefined} options.compression compression used
-	 * @param {boolean | undefined} options.readonly disable storing cache into filesystem
+	 * @param {boolean=} options.profile track and log detailed timing information for individual cache items
+	 * @param {boolean=} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli"=} options.compression compression used
+	 * @param {boolean=} options.readonly disable storing cache into filesystem
 	 */
 	constructor({
 		compiler,
@@ -1113,31 +1130,44 @@ class PackFileCacheStrategy {
 		/** @type {import("../serialization/Serializer")<PackContainer, null, EXPECTED_OBJECT>} */
 		this.fileSerializer = createFileSerializer(
 			fs,
-			/** @type {string | Hash} */
+			/** @type {HashFunction} */
 			(compiler.options.output.hashFunction)
 		);
+		/** @type {FileSystemInfo} */
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
 			immutablePaths: snapshot.immutablePaths,
 			logger: logger.getChildLogger("webpack.FileSystemInfo"),
 			hashFunction: compiler.options.output.hashFunction
 		});
+		/** @type {Compiler} */
 		this.compiler = compiler;
+		/** @type {string} */
 		this.context = context;
+		/** @type {string} */
 		this.cacheLocation = cacheLocation;
+		/** @type {string} */
 		this.version = version;
+		/** @type {Logger} */
 		this.logger = logger;
+		/** @type {number} */
 		this.maxAge = maxAge;
+		/** @type {boolean | undefined} */
 		this.profile = profile;
+		/** @type {boolean | undefined} */
 		this.readonly = readonly;
+		/** @type {boolean | undefined} */
 		this.allowCollectingMemory = allowCollectingMemory;
+		/** @type {false | "gzip" | "brotli" | undefined} */
 		this.compression = compression;
+		/** @type {string} */
 		this._extension =
 			compression === "brotli"
 				? ".pack.br"
 				: compression === "gzip"
 					? ".pack.gz"
 					: ".pack";
+		/** @type {SnapshotOptions} */
 		this.snapshot = snapshot;
 		/** @type {BuildDependencies} */
 		this.buildDependencies = new Set();
@@ -1151,6 +1181,7 @@ class PackFileCacheStrategy {
 		this.buildSnapshot = undefined;
 		/** @type {Promise<Pack> | undefined} */
 		this.packPromise = this._openPack();
+		/** @type {Promise<void>} */
 		this.storePromise = Promise.resolve();
 	}
 
@@ -1382,7 +1413,9 @@ class PackFileCacheStrategy {
 				if (!pack.invalid) return;
 				this.packPromise = undefined;
 				this.logger.log("Storing pack...");
+				/** @type {undefined | Promise<void>} */
 				let promise;
+				/** @type {Set<string>} */
 				const newBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
 					if (!this.buildDependencies.has(dep)) {

package/lib/cache/getLazyHashedEtag.js

@@ -10,6 +10,7 @@ const createHash = require("../util/createHash");
 
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 
 /**
  * @typedef {object} HashableObject
@@ -19,11 +20,14 @@ const createHash = require("../util/createHash");
 class LazyHashedEtag {
 	/**
 	 * @param {HashableObject} obj object with updateHash method
-	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(obj, hashFunction = DEFAULTS.HASH_FUNCTION) {
+		/** @type {HashableObject} */
 		this._obj = obj;
+		/** @type {undefined | string} */
 		this._hash = undefined;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -40,23 +44,27 @@ class LazyHashedEtag {
 	}
 }
 
-/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+/** @typedef {WeakMap<HashableObject, LazyHashedEtag>} InnerCache */
+
+/** @type {Map<HashFunction, InnerCache>} */
 const mapStrings = new Map();
 
-/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+/** @type {WeakMap<HashConstructor, InnerCache>} */
 const mapObjects = new WeakMap();
 
 /**
  * @param {HashableObject} obj object with updateHash method
- * @param {(string | HashConstructor)=} hashFunction the hash function to use
+ * @param {HashFunction=} hashFunction the hash function to use
  * @returns {LazyHashedEtag} etag
  */
 const getter = (obj, hashFunction = DEFAULTS.HASH_FUNCTION) => {
+	/** @type {undefined | InnerCache} */
 	let innerMap;
 	if (typeof hashFunction === "string") {
 		innerMap = mapStrings.get(hashFunction);
 		if (innerMap === undefined) {
 			const newHash = new LazyHashedEtag(obj, hashFunction);
+			/** @type {InnerCache} */
 			innerMap = new WeakMap();
 			innerMap.set(obj, newHash);
 			mapStrings.set(hashFunction, innerMap);
@@ -66,6 +74,7 @@ const getter = (obj, hashFunction = DEFAULTS.HASH_FUNCTION) => {
 		innerMap = mapObjects.get(hashFunction);
 		if (innerMap === undefined) {
 			const newHash = new LazyHashedEtag(obj, hashFunction);
+			/** @type {InnerCache} */
 			innerMap = new WeakMap();
 			innerMap.set(obj, newHash);
 			mapObjects.set(hashFunction, innerMap);

package/lib/cache/mergeEtags.js

@@ -22,13 +22,15 @@ class MergedEtag {
 	}
 }
 
+/** @type {WeakMap<Etag, WeakMap<Etag, MergedEtag>>} */
 const dualObjectMap = new WeakMap();
+/** @type {WeakMap<Etag, WeakMap<Etag, MergedEtag>>} */
 const objectStringMap = new WeakMap();
 
 /**
  * @param {Etag} a first
  * @param {Etag} b second
- * @returns {Etag} result
+ * @returns {string | MergedEtag} result
  */
 const mergeEtags = (a, b) => {
 	if (typeof a === "string") {

package/lib/cli.js

@@ -427,6 +427,7 @@ const getArguments = (schema = webpackSchema) => {
 	return flags;
 };
 
+/** @type {WeakMap<EXPECTED_OBJECT, number>} */
 const cliAddedItems = new WeakMap();
 
 /** @typedef {string | number} Property */
@@ -621,7 +622,7 @@ const parseValueForArgumentConfig = (argConfig, value) => {
 			break;
 		case "number":
 			if (typeof value === "number") return value;
-			if (typeof value === "string" && /^[+-]?\d*(\.\d*)[eE]\d+$/) {
+			if (typeof value === "string" && /^[+-]?\d*(\.\d*)e\d+$/i) {
 				const n = Number(value);
 				if (!Number.isNaN(n)) return n;
 			}
@@ -685,6 +686,7 @@ const processArguments = (args, config, values) => {
 		 * @param {number | undefined} i index
 		 */
 		const processValue = (value, i) => {
+			/** @type {Problem[]} */
 			const currentProblems = [];
 			for (const argConfig of arg.configs) {
 				const problem = processArgumentConfig(argConfig, config, value, i);