webpack 5.97.1 → 5.104.1

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -17,7 +17,7 @@ module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 	 */
 	constructor(assetsOverSizeLimit, assetLimit) {
 		const assetLists = assetsOverSizeLimit
-			.map(asset => `\n  ${asset.name} (${formatSize(asset.size)})`)
+			.map((asset) => `\n  ${asset.name} (${formatSize(asset.size)})`)
 			.join("");
 
 		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -18,10 +18,10 @@ module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
 	constructor(entrypoints, entrypointLimit) {
 		const entrypointList = entrypoints
 			.map(
-				entrypoint =>
+				(entrypoint) =>
 					`\n  ${entrypoint.name} (${formatSize(
 						entrypoint.size
-					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
+					)})\n${entrypoint.files.map((asset) => `      ${asset}`).join("\n")}`
 			)
 			.join("");
 		super(`entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${formatSize(

package/lib/performance/SizeLimitsPlugin.js

@@ -31,6 +31,7 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
  * @property {string[]} files
  */
 
+/** @type {WeakSet<Entrypoint | ChunkGroup | Source>} */
 const isOverSizeLimitSet = new WeakSet();
 
 /**
@@ -41,6 +42,8 @@ const isOverSizeLimitSet = new WeakSet();
  */
 const excludeSourceMap = (name, source, info) => !info.development;
 
+const PLUGIN_NAME = "SizeLimitsPlugin";
+
 module.exports = class SizeLimitsPlugin {
 	/**
 	 * @param {PerformanceOptions} options the plugin options
@@ -53,7 +56,7 @@ module.exports = class SizeLimitsPlugin {
 	}
 
 	/**
-	 * @param {ChunkGroup | Source} thing the resource to test
+	 * @param {Entrypoint | ChunkGroup | Source} thing the resource to test
 	 * @returns {boolean} true if over the limit
 	 */
 	static isOverSizeLimit(thing) {
@@ -71,7 +74,7 @@ module.exports = class SizeLimitsPlugin {
 		const hints = this.hints;
 		const assetFilter = this.assetFilter || excludeSourceMap;
 
-		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
+		compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
 			/** @type {WebpackError[]} */
 			const warnings = [];
 
@@ -79,7 +82,7 @@ module.exports = class SizeLimitsPlugin {
 			 * @param {Entrypoint} entrypoint an entrypoint
 			 * @returns {number} the size of the entrypoint
 			 */
-			const getEntrypointSize = entrypoint => {
+			const getEntrypointSize = (entrypoint) => {
 				let size = 0;
 				for (const file of entrypoint.getFiles()) {
 					const asset = compilation.getAsset(file);
@@ -115,7 +118,7 @@ module.exports = class SizeLimitsPlugin {
 			 * @param {Asset["name"]} name the name
 			 * @returns {boolean | undefined} result
 			 */
-			const fileFilter = name => {
+			const fileFilter = (name) => {
 				const asset = compilation.getAsset(name);
 				return asset && assetFilter(asset.name, asset.source, asset.info);
 			};
@@ -160,7 +163,7 @@ module.exports = class SizeLimitsPlugin {
 				if (warnings.length > 0) {
 					const someAsyncChunk = find(
 						compilation.chunks,
-						chunk => !chunk.canBeInitial()
+						(chunk) => !chunk.canBeInitial()
 					);
 
 					if (!someAsyncChunk) {

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -8,17 +8,15 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {string} childType TODO
-	 * @param {string} runtimeFunction TODO
-	 * @param {string} runtimeHandlers TODO
+	 * @param {"prefetch" | "preload"} type "prefetch" or "preload" chunk type function
+	 * @param {string} runtimeFunction the runtime function name
+	 * @param {string} runtimeHandlers the runtime handlers
 	 */
-	constructor(childType, runtimeFunction, runtimeHandlers) {
-		super(`chunk ${childType} function`);
-		this.childType = childType;
+	constructor(type, runtimeFunction, runtimeHandlers) {
+		super(`chunk ${type} function`);
 		this.runtimeFunction = runtimeFunction;
 		this.runtimeHandlers = runtimeHandlers;
 	}

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -11,87 +11,84 @@ const ChunkPrefetchStartupRuntimeModule = require("./ChunkPrefetchStartupRuntime
 const ChunkPrefetchTriggerRuntimeModule = require("./ChunkPrefetchTriggerRuntimeModule");
 const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "ChunkPrefetchPreloadPlugin";
+
 class ChunkPrefetchPreloadPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ChunkPrefetchPreloadPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
-						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
-							chunkGraph,
-							"prefetchOrder"
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
+					const startupChildChunks = chunk.getChildrenOfTypeInOrder(
+						chunkGraph,
+						"prefetchOrder"
+					);
+					if (startupChildChunks) {
+						set.add(RuntimeGlobals.prefetchChunk);
+						set.add(RuntimeGlobals.onChunksLoaded);
+						set.add(RuntimeGlobals.exports);
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
 						);
-						if (startupChildChunks) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.exports);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
-							);
-						}
 					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
+				}
+			);
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
 
-						if (chunkMap.prefetch) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
-							);
-						}
-						if (chunkMap.preload) {
-							set.add(RuntimeGlobals.preloadChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					if (chunkMap.prefetch) {
+						set.add(RuntimeGlobals.prefetchChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"prefetch",
-								RuntimeGlobals.prefetchChunk,
-								RuntimeGlobals.prefetchChunkHandlers
-							)
+							new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
 						);
-						set.add(RuntimeGlobals.prefetchChunkHandlers);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					}
+					if (chunkMap.preload) {
+						set.add(RuntimeGlobals.preloadChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"preload",
-								RuntimeGlobals.preloadChunk,
-								RuntimeGlobals.preloadChunkHandlers
-							)
+							new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
 						);
-						set.add(RuntimeGlobals.preloadChunkHandlers);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.prefetchChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"prefetch",
+							RuntimeGlobals.prefetchChunk,
+							RuntimeGlobals.prefetchChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.prefetchChunkHandlers);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.preloadChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"preload",
+							RuntimeGlobals.preloadChunk,
+							RuntimeGlobals.preloadChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.preloadChunkHandlers);
+				});
+		});
 	}
 }
 

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -10,7 +10,6 @@ const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	/**
@@ -34,16 +33,16 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 				({ onChunks, chunks }) =>
 					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
 						// This need to include itself to delay execution after this chunk has been fully loaded
-						onChunks.filter(c => c === chunk).map(c => c.id)
+						onChunks.filter((c) => c === chunk).map((c) => c.id)
 					)}, ${runtimeTemplate.basicFunction(
 						"",
 						chunks.size < 3
 							? Array.from(
 									chunks,
-									c =>
+									(c) =>
 										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
 								)
-							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
+							: `${JSON.stringify(Array.from(chunks, (c) => c.id))}.map(${
 									RuntimeGlobals.prefetchChunk
 								});`
 					)}, 5);`

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -9,11 +9,11 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
+	 * @param {ChunkChildIdsByOrdersMap} chunkMap map from chunk to
 	 */
 	constructor(chunkMap) {
 		super("chunk prefetch trigger", RuntimeModule.STAGE_TRIGGER);

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -9,11 +9,11 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
+	 * @param {ChunkChildIdsByOrdersMap} chunkMap map from chunk to chunks
 	 */
 	constructor(chunkMap) {
 		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);

package/lib/rules/BasicEffectRulePlugin.js

@@ -8,9 +8,19 @@
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
+
+const PLUGIN_NAME = "BasicEffectRulePlugin";
+
 class BasicEffectRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
+	 * @param {BasicEffectRuleKeys} ruleProperty the rule property
 	 * @param {string=} effectType the effect type
 	 */
 	constructor(ruleProperty, effectType) {
@@ -24,13 +34,12 @@ class BasicEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
+			PLUGIN_NAME,
+			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 
-					const value =
-						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+					const value = rule[this.ruleProperty];
 
 					result.effects.push({
 						type: this.effectType,

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,13 +5,24 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditionsAbsolute} RuleSetConditionOrConditionsAbsolute */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute>} BasicMatcherRuleKeys */
+
+const PLUGIN_NAME = "BasicMatcherRulePlugin";
 
 class BasicMatcherRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
+	 * @param {BasicMatcherRuleKeys} ruleProperty the rule property
 	 * @param {string=} dataProperty the data property
 	 * @param {boolean=} invert if true, inverts the condition
 	 */
@@ -27,15 +38,15 @@ class BasicMatcherRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
-					const value =
-						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+					const value = rule[this.ruleProperty];
 					const condition = ruleSetCompiler.compileCondition(
 						`${path}.${this.ruleProperty}`,
-						value
+						/** @type {RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute} */
+						(value)
 					);
 					const fn = condition.fn;
 					result.conditions.push({
@@ -43,7 +54,7 @@ class BasicMatcherRulePlugin {
 						matchWhenEmpty: this.invert
 							? !condition.matchWhenEmpty
 							: condition.matchWhenEmpty,
-						fn: this.invert ? v => !fn(v) : fn
+						fn: this.invert ? (v) => !fn(v) : fn
 					});
 				}
 			}

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,15 +5,26 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, { [k: string]: RuleSetConditionOrConditions }>} ObjectMatcherRuleKeys */
+
+const PLUGIN_NAME = "ObjectMatcherRulePlugin";
+
 class ObjectMatcherRulePlugin {
 	/**
-	 * @param {string} ruleProperty the rule property
-	 * @param {string=} dataProperty the data property
+	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
+	 * @param {keyof EffectData=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
 	 */
 	constructor(ruleProperty, dataProperty, additionalConditionFunction) {
@@ -29,13 +40,13 @@ class ObjectMatcherRulePlugin {
 	apply(ruleSetCompiler) {
 		const { ruleProperty, dataProperty } = this;
 		ruleSetCompiler.hooks.rule.tap(
-			"ObjectMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);
 					const value =
-						/** @type {Record<string, any>} */
-						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
+						/** @type {Record<string, RuleSetConditionOrConditions>} */
+						(rule[ruleProperty]);
 					for (const property of Object.keys(value)) {
 						const nestedDataProperties = property.split(".");
 						const condition = ruleSetCompiler.compileCondition(