webpack 5.99.7 → 5.99.9

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -195,7 +195,7 @@ class AggressiveSplittingPlugin {
 								moveModuleBetween(chunkGraph, chunk, newChunk)(module);
 							}
 							chunk.split(newChunk);
-							chunk.name = /** @type {TODO} */ (null);
+							chunk.name = null;
 						}
 						fromAggressiveSplittingSet.add(newChunk);
 						chunkSplitDataMap.set(newChunk, splitData);

package/lib/optimize/ConcatenatedModule.js

@@ -1739,7 +1739,9 @@ ${defineGetters}`
 						sourceType: "module"
 					});
 				} catch (_err) {
-					const err = /** @type {TODO} */ (_err);
+					const err =
+						/** @type {Error & { loc?: { line: number, column: number } }} */
+						(_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -398,9 +398,9 @@ class ModuleConcatenationPlugin {
 								newModule.build(
 									compiler.options,
 									compilation,
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
 									err => {
 										if (err) {

package/lib/optimize/RuntimeChunkPlugin.js

@@ -11,16 +11,15 @@
 
 const PLUGIN_NAME = "RuntimeChunkPlugin";
 
+/** @typedef {(entrypoint: { name: string }) => string} RuntimeChunkFunction */
+
 class RuntimeChunkPlugin {
 	/**
-	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options) {
 		this.options = {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint name
-			 * @returns {string} runtime chunk name
-			 */
+			/** @type {RuntimeChunkFunction} */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -41,7 +40,7 @@ class RuntimeChunkPlugin {
 				if (data.options.runtime === undefined && !data.options.dependOn) {
 					// Determine runtime chunk name
 					let name =
-						/** @type {string | ((entrypoint: { name: string }) => string)} */
+						/** @type {string | RuntimeChunkFunction} */
 						(this.options.name);
 					if (typeof name === "function") {
 						name = name({ name: entryName });

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -105,7 +105,9 @@ class SideEffectsFlagPlugin {
 							}
 							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
 								resolveData.relativePath,
-								sideEffects,
+								/** @type {string | boolean | string[] | undefined} */ (
+									sideEffects
+								),
 								/** @type {CacheItem} */ (cache)
 							);
 							module.factoryMeta.sideEffectFree = !hasSideEffects;
@@ -145,7 +147,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.expression,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -157,7 +160,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.test,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -193,7 +197,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.discriminant,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -216,9 +221,9 @@ class SideEffectsFlagPlugin {
 									case "ExportDefaultDeclaration":
 										if (
 											!parser.isPure(
-												/** @type {TODO} */
-												(statement.declaration),
-												/** @type {Range} */ (statement.range)[0]
+												statement.declaration,
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;

package/lib/optimize/SplitChunksPlugin.js

@@ -21,6 +21,7 @@ const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
@@ -33,7 +34,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
@@ -184,7 +184,7 @@ const hashFilename = (name, outputOptions) => {
 	const digest =
 		/** @type {string} */
 		(
-			createHash(/** @type {Algorithm} */ (outputOptions.hashFunction))
+			createHash(/** @type {HashFunction} */ (outputOptions.hashFunction))
 				.update(name)
 				.digest(outputOptions.hashDigest)
 		);

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/schemes/DataUriPlugin.js

@@ -56,7 +56,9 @@ class DataUriPlugin {
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
 							resourceData.data.parameters = match[2] || "";
-							resourceData.data.encoding = match[3] || false;
+							resourceData.data.encoding = /** @type {"base64" | false} */ (
+								match[3] || false
+							);
 							resourceData.data.encodedContent = match[4] || "";
 						}
 					});

package/lib/schemes/HttpUriPlugin.js

@@ -16,6 +16,7 @@ const { mkdirp, dirname, join } = require("../util/fs");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").OutgoingHttpHeaders} OutgoingHttpHeaders */
 /** @typedef {import("http").RequestOptions} RequestOptions */
 /** @typedef {import("net").Socket} Socket */
 /** @typedef {import("stream").Readable} Readable */
@@ -147,7 +148,7 @@ const parseKeyValuePairs = str => {
 /**
  * @param {string | undefined} cacheControl Cache-Control header
  * @param {number} requestTime timestamp of request
- * @returns {{storeCache: boolean, storeLock: boolean, validUntil: number}} Logic for storing in cache and lockfile cache
+ * @returns {{ storeCache: boolean, storeLock: boolean, validUntil: number }} Logic for storing in cache and lockfile cache
  */
 const parseCacheControl = (cacheControl, requestTime) => {
 	// When false resource is not stored in cache
@@ -190,7 +191,7 @@ const areLockfileEntriesEqual = (a, b) =>
 
 /**
  * @param {LockfileEntry} entry lockfile entry
- * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${*}`} stringified entry
+ * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${string}`} stringified entry
  */
 const entryToString = entry =>
 	`resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
@@ -636,11 +637,14 @@ class HttpUriPlugin {
 					const resolveContent = (url, integrity, callback) => {
 						/**
 						 * @param {Error | null} err error
-						 * @param {TODO} result result result
+						 * @param {FetchResult=} _result fetch result
 						 * @returns {void}
 						 */
-						const handleResult = (err, result) => {
+						const handleResult = (err, _result) => {
 							if (err) return callback(err);
+
+							const result = /** @type {FetchResult} */ (_result);
+
 							if ("location" in result) {
 								return resolveContent(
 									result.location,
@@ -657,6 +661,7 @@ class HttpUriPlugin {
 									}
 								);
 							}
+
 							if (
 								!result.fresh &&
 								integrity &&
@@ -665,12 +670,14 @@ class HttpUriPlugin {
 							) {
 								return fetchContent.force(url, handleResult);
 							}
+
 							return callback(null, {
 								entry: result.entry,
 								content: result.content,
 								storeLock: result.storeLock
 							});
 						};
+
 						fetchContent(url, handleResult);
 					};
 
@@ -682,164 +689,162 @@ class HttpUriPlugin {
 					 */
 					const fetchContentRaw = (url, cachedResult, callback) => {
 						const requestTime = Date.now();
-						fetch(
-							new URL(url),
-							{
-								headers: {
-									"accept-encoding": "gzip, deflate, br",
-									"user-agent": "webpack",
-									"if-none-match": /** @type {TODO} */ (
-										cachedResult ? cachedResult.etag || null : null
-									)
-								}
-							},
-							res => {
-								const etag = res.headers.etag;
-								const location = res.headers.location;
-								const cacheControl = res.headers["cache-control"];
-								const { storeLock, storeCache, validUntil } = parseCacheControl(
-									cacheControl,
-									requestTime
-								);
-								/**
-								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
-								 * @returns {void}
-								 */
-								const finishWith = partialResult => {
-									if ("location" in partialResult) {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
-										);
-									} else {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] ${Math.ceil(
-												partialResult.content.length / 1024
-											)} kB${!storeLock ? " no-cache" : ""}`
-										);
-									}
-									const result = {
-										...partialResult,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									};
-									if (!storeCache) {
-										logger.log(
-											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
-										);
-										return callback(null, result);
-									}
-									cache.store(
-										url,
-										null,
-										{
-											...result,
-											fresh: false
-										},
-										err => {
-											if (err) {
-												logger.warn(
-													`${url} can't be stored in cache: ${err.message}`
-												);
-												logger.debug(err.stack);
-											}
-											callback(null, result);
-										}
+						/** @type {OutgoingHttpHeaders} */
+						const headers = {
+							"accept-encoding": "gzip, deflate, br",
+							"user-agent": "webpack"
+						};
+
+						if (cachedResult && cachedResult.etag) {
+							headers["if-none-match"] = cachedResult.etag;
+						}
+
+						fetch(new URL(url), { headers }, res => {
+							const etag = res.headers.etag;
+							const location = res.headers.location;
+							const cacheControl = res.headers["cache-control"];
+							const { storeLock, storeCache, validUntil } = parseCacheControl(
+								cacheControl,
+								requestTime
+							);
+							/**
+							 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
+							 * @returns {void}
+							 */
+							const finishWith = partialResult => {
+								if ("location" in partialResult) {
+									logger.debug(
+										`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
+									);
+								} else {
+									logger.debug(
+										`GET ${url} [${res.statusCode}] ${Math.ceil(
+											partialResult.content.length / 1024
+										)} kB${!storeLock ? " no-cache" : ""}`
 									);
+								}
+								const result = {
+									...partialResult,
+									fresh: true,
+									storeLock,
+									storeCache,
+									validUntil,
+									etag
 								};
-								if (res.statusCode === 304) {
-									const result = /** @type {FetchResult} */ (cachedResult);
-									if (
-										result.validUntil < validUntil ||
-										result.storeLock !== storeLock ||
-										result.storeCache !== storeCache ||
-										result.etag !== etag
-									) {
-										return finishWith(result);
-									}
-									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-									return callback(null, { ...result, fresh: true });
+								if (!storeCache) {
+									logger.log(
+										`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
+									);
+									return callback(null, result);
 								}
+								cache.store(
+									url,
+									null,
+									{
+										...result,
+										fresh: false
+									},
+									err => {
+										if (err) {
+											logger.warn(
+												`${url} can't be stored in cache: ${err.message}`
+											);
+											logger.debug(err.stack);
+										}
+										callback(null, result);
+									}
+								);
+							};
+							if (res.statusCode === 304) {
+								const result = /** @type {FetchResult} */ (cachedResult);
 								if (
-									location &&
-									res.statusCode &&
-									res.statusCode >= 301 &&
-									res.statusCode <= 308
+									result.validUntil < validUntil ||
+									result.storeLock !== storeLock ||
+									result.storeCache !== storeCache ||
+									result.etag !== etag
 								) {
-									const result = {
-										location: new URL(location, url).href
-									};
-									if (
-										!cachedResult ||
-										!("location" in cachedResult) ||
-										cachedResult.location !== result.location ||
-										cachedResult.validUntil < validUntil ||
-										cachedResult.storeLock !== storeLock ||
-										cachedResult.storeCache !== storeCache ||
-										cachedResult.etag !== etag
-									) {
-										return finishWith(result);
-									}
-									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-									return callback(null, {
-										...result,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									});
+									return finishWith(result);
 								}
-								const contentType = res.headers["content-type"] || "";
-								/** @type {Buffer[]} */
-								const bufferArr = [];
-
-								const contentEncoding = res.headers["content-encoding"];
-								/** @type {Readable} */
-								let stream = res;
-								if (contentEncoding === "gzip") {
-									stream = stream.pipe(createGunzip());
-								} else if (contentEncoding === "br") {
-									stream = stream.pipe(createBrotliDecompress());
-								} else if (contentEncoding === "deflate") {
-									stream = stream.pipe(createInflate());
+								logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+								return callback(null, { ...result, fresh: true });
+							}
+							if (
+								location &&
+								res.statusCode &&
+								res.statusCode >= 301 &&
+								res.statusCode <= 308
+							) {
+								const result = {
+									location: new URL(location, url).href
+								};
+								if (
+									!cachedResult ||
+									!("location" in cachedResult) ||
+									cachedResult.location !== result.location ||
+									cachedResult.validUntil < validUntil ||
+									cachedResult.storeLock !== storeLock ||
+									cachedResult.storeCache !== storeCache ||
+									cachedResult.etag !== etag
+								) {
+									return finishWith(result);
 								}
-
-								stream.on("data", chunk => {
-									bufferArr.push(chunk);
+								logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+								return callback(null, {
+									...result,
+									fresh: true,
+									storeLock,
+									storeCache,
+									validUntil,
+									etag
 								});
+							}
+							const contentType = res.headers["content-type"] || "";
+							/** @type {Buffer[]} */
+							const bufferArr = [];
 
-								stream.on("end", () => {
-									if (!res.complete) {
-										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
-										return callback(new Error(`${url} request was terminated`));
-									}
+							const contentEncoding = res.headers["content-encoding"];
+							/** @type {Readable} */
+							let stream = res;
+							if (contentEncoding === "gzip") {
+								stream = stream.pipe(createGunzip());
+							} else if (contentEncoding === "br") {
+								stream = stream.pipe(createBrotliDecompress());
+							} else if (contentEncoding === "deflate") {
+								stream = stream.pipe(createInflate());
+							}
 
-									const content = Buffer.concat(bufferArr);
+							stream.on("data", chunk => {
+								bufferArr.push(chunk);
+							});
 
-									if (res.statusCode !== 200) {
-										logger.log(`GET ${url} [${res.statusCode}]`);
-										return callback(
-											new Error(
-												`${url} request status code = ${
-													res.statusCode
-												}\n${content.toString("utf-8")}`
-											)
-										);
-									}
+							stream.on("end", () => {
+								if (!res.complete) {
+									logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
+									return callback(new Error(`${url} request was terminated`));
+								}
 
-									const integrity = computeIntegrity(content);
-									const entry = { resolved: url, integrity, contentType };
+								const content = Buffer.concat(bufferArr);
 
-									finishWith({
-										entry,
-										content
-									});
+								if (res.statusCode !== 200) {
+									logger.log(`GET ${url} [${res.statusCode}]`);
+									return callback(
+										new Error(
+											`${url} request status code = ${
+												res.statusCode
+											}\n${content.toString("utf-8")}`
+										)
+									);
+								}
+
+								const integrity = computeIntegrity(content);
+								const entry = { resolved: url, integrity, contentType };
+
+								finishWith({
+									entry,
+									content
 								});
-							}
-						).on("error", err => {
+							});
+						}).on("error", err => {
 							logger.log(`GET ${url} (error)`);
 							err.message += `\nwhile fetching ${url}`;
 							callback(err);
@@ -849,7 +854,7 @@ class HttpUriPlugin {
 					const fetchContent = cachedWithKey(
 						/**
 						 * @param {string} url URL
-						 * @param {(err: Error | null, result?: { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }) => void} callback callback
+						 * @param {(err: Error | null, result?: FetchResult) => void} callback callback
 						 * @returns {void}
 						 */
 						(url, callback) => {