webpack 5.99.6 → 5.99.8

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -15,83 +15,82 @@ const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeMo
 /** @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/rules/BasicEffectRulePlugin.js

@@ -37,8 +37,7 @@ class BasicEffectRulePlugin {
 				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/ObjectMatcherRulePlugin.js

@@ -8,6 +8,7 @@
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
@@ -22,7 +23,7 @@
 class ObjectMatcherRulePlugin {
 	/**
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
-	 * @param {string=} dataProperty the data property
+	 * @param {keyof EffectData=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
 	 */
 	constructor(ruleProperty, dataProperty, additionalConditionFunction) {

package/lib/rules/RuleSetCompiler.js

@@ -13,7 +13,9 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
-/** @typedef {(value: string | EffectData) => boolean} RuleConditionFunction */
+/**
+ * @typedef {(value: EffectData[keyof EffectData]) => boolean} RuleConditionFunction
+ */
 
 /**
  * @typedef {object} RuleCondition
@@ -29,7 +31,19 @@ const { SyncHook } = require("tapable");
  */
 
 /**
- * @typedef {Record<string, TODO>} EffectData
+ * @typedef {object} EffectData
+ * @property {string=} resource
+ * @property {string=} realResource
+ * @property {string=} resourceQuery
+ * @property {string=} resourceFragment
+ * @property {string=} scheme
+ * @property {ImportAttributes=} assertions
+ * @property {string=} mimetype
+ * @property {string} dependency
+ * @property {Record<string, EXPECTED_ANY>} descriptionData
+ * @property {string=} compiler
+ * @property {string} issuer
+ * @property {string} issuerLayer
  */
 
 /**
@@ -102,7 +116,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EffectData | string | undefined} */
+					/** @type {EffectData | EffectData[keyof EffectData] | undefined} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -110,7 +124,7 @@ class RuleSetCompiler {
 							typeof current === "object" &&
 							Object.prototype.hasOwnProperty.call(current, subProperty)
 						) {
-							current = current[subProperty];
+							current = current[/** @type {keyof EffectData} */ (subProperty)];
 						} else {
 							current = undefined;
 							break;
@@ -121,7 +135,7 @@ class RuleSetCompiler {
 						continue;
 					}
 				} else if (p in data) {
-					const value = data[p];
+					const value = data[/** @type {keyof EffectData} */ (p)];
 					if (value !== undefined) {
 						if (!condition.fn(value)) return false;
 						continue;

package/lib/rules/UseEffectRulePlugin.js

@@ -15,6 +15,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
 
 class UseEffectRulePlugin {
 	/**
@@ -55,7 +56,7 @@ class UseEffectRulePlugin {
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
 					 * @param {RuleSetUseItem} item user provided use value
-					 * @returns {Effect | ((value: TODO) => Effect[])} effect
+					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))} effect
 					 */
 					const useToEffect = (path, defaultIdent, item) => {
 						if (typeof item === "function") {
@@ -139,7 +140,7 @@ class UseEffectRulePlugin {
 					/**
 					 * @param {string} path current path
 					 * @param {RuleSetUse} items user provided use value
-					 * @returns {(Effect | ((value: TODO) => Effect[]))[]} effects
+					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
 					 */
 					const useToEffects = (path, items) => {
 						if (Array.isArray(items)) {
@@ -160,10 +161,7 @@ class UseEffectRulePlugin {
 
 					if (typeof use === "function") {
 						result.effects.push(data =>
-							useToEffectsWithoutIdent(
-								`${path}.use`,
-								use(/** @type {TODO} */ (data))
-							)
+							useToEffectsWithoutIdent(`${path}.use`, use(data))
 						);
 					} else {
 						for (const effect of useToEffects(`${path}.use`, use)) {

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -18,6 +18,8 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
  * @property {boolean=} asyncChunkLoading
  */
 
+const PLUGIN_NAME = "StartupChunkDependenciesPlugin";
+
 class StartupChunkDependenciesPlugin {
 	/**
 	 * @param {Options} options options
@@ -36,53 +38,48 @@ class StartupChunkDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @returns {boolean} true, when the plugin is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
-				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @returns {boolean} true, when the plugin is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === this.chunkLoading;
+			};
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) return;
+					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+						set.add(RuntimeGlobals.startup);
 						set.add(RuntimeGlobals.ensureChunk);
 						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
 						compilation.addRuntimeModule(
 							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+							new StartupChunkDependenciesRuntimeModule(this.asyncChunkLoading)
 						);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.startupEntrypoint)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.require);
+					set.add(RuntimeGlobals.ensureChunk);
+					set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+					compilation.addRuntimeModule(
+						chunk,
+						new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+					);
+				});
+		});
 	}
 }
 

package/lib/schemes/DataUriPlugin.js

@@ -37,6 +37,8 @@ const decodeDataURI = uri => {
 	}
 };
 
+const PLUGIN_NAME = "DataUriPlugin";
+
 class DataUriPlugin {
 	/**
 	 * Apply the plugin
@@ -45,11 +47,11 @@ class DataUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DataUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
-					.tap("DataUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const match = URIRegEx.exec(resourceData.resource);
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
@@ -60,7 +62,7 @@ class DataUriPlugin {
 					});
 				NormalModule.getCompilationHooks(compilation)
 					.readResourceForScheme.for("data")
-					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+					.tap(PLUGIN_NAME, resource => decodeDataURI(resource));
 			}
 		);
 	}

package/lib/schemes/FileUriPlugin.js

@@ -10,6 +10,8 @@ const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "FileUriPlugin";
+
 class FileUriPlugin {
 	/**
 	 * Apply the plugin
@@ -18,11 +20,11 @@ class FileUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"FileUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("file")
-					.tap("FileUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const url = new URL(resourceData.resource);
 						const path = fileURLToPath(url);
 						const query = url.search;
@@ -36,7 +38,7 @@ class FileUriPlugin {
 				const hooks = NormalModule.getCompilationHooks(compilation);
 				hooks.readResource
 					.for(undefined)
-					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+					.tapAsync(PLUGIN_NAME, (loaderContext, callback) => {
 						const { resourcePath } = loaderContext;
 						loaderContext.addDependency(resourcePath);
 						loaderContext.fs.readFile(resourcePath, callback);