webpack 5.98.0 → 5.99.0

package/lib/rules/UseEffectRulePlugin.js

@@ -7,9 +7,12 @@
 
 const util = require("util");
 
+/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 
@@ -43,7 +46,7 @@ class UseEffectRulePlugin {
 					conflictWith("loader", "use");
 					conflictWith("options", "use");
 
-					const use = rule.use;
+					const use = /** @type {RuleSetUse} */ (rule.use);
 					const enforce = rule.enforce;
 
 					const type = enforce ? `use-${enforce}` : "use";
@@ -51,12 +54,17 @@ class UseEffectRulePlugin {
 					/**
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect|function(any): Effect[]} effect
+					 * @param {RuleSetUseItem} item user provided use value
+					 * @returns {Effect | ((value: TODO) => Effect[])} effect
 					 */
 					const useToEffect = (path, defaultIdent, item) => {
 						if (typeof item === "function") {
-							return data => useToEffectsWithoutIdent(path, item(data));
+							return data =>
+								useToEffectsWithoutIdent(
+									path,
+									/** @type {RuleSetUseItem | RuleSetUseItem[]} */
+									(item(data))
+								);
 						}
 						return useToEffectRaw(path, defaultIdent, item);
 					};
@@ -64,7 +72,7 @@ class UseEffectRulePlugin {
 					/**
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -104,33 +112,50 @@ class UseEffectRulePlugin {
 
 					/**
 					 * @param {string} path options path
-					 * @param {any} items user provided use value
+					 * @param {RuleSetUseItem | (Falsy | RuleSetUseItem)[]} items user provided use value
 					 * @returns {Effect[]} effects
 					 */
 					const useToEffectsWithoutIdent = (path, items) => {
 						if (Array.isArray(items)) {
-							return items
-								.filter(Boolean)
-								.map((item, idx) =>
-									useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
-								);
+							return items.filter(Boolean).map((item, idx) =>
+								useToEffectRaw(
+									`${path}[${idx}]`,
+									"[[missing ident]]",
+									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									(item)
+								)
+							);
 						}
-						return [useToEffectRaw(path, "[[missing ident]]", items)];
+						return [
+							useToEffectRaw(
+								path,
+								"[[missing ident]]",
+								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								(items)
+							)
+						];
 					};
 
 					/**
 					 * @param {string} path current path
-					 * @param {any} items user provided use value
-					 * @returns {(Effect|function(any): Effect[])[]} effects
+					 * @param {RuleSetUse} items user provided use value
+					 * @returns {(Effect | ((value: TODO) => Effect[]))[]} effects
 					 */
 					const useToEffects = (path, items) => {
 						if (Array.isArray(items)) {
 							return items.filter(Boolean).map((item, idx) => {
 								const subPath = `${path}[${idx}]`;
-								return useToEffect(subPath, subPath, item);
+								return useToEffect(
+									subPath,
+									subPath,
+									/** @type {RuleSetUseItem} */
+									(item)
+								);
 							});
 						}
-						return [useToEffect(path, path, items)];
+						return [
+							useToEffect(path, path, /** @type {RuleSetUseItem} */ (items))
+						];
 					};
 
 					if (typeof use === "function") {
@@ -182,7 +207,12 @@ class UseEffectRulePlugin {
 
 					const ident =
 						options && typeof options === "object" ? path : undefined;
-					references.set(ident, options);
+					references.set(
+						/** @type {TODO} */
+						(ident),
+						/** @type {RuleSetLoaderOptions} */
+						(options)
+					);
 					result.effects.push({
 						type: enforce ? `use-${enforce}` : "use",
 						value: {

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -20,7 +20,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): TemplatePath | false} getFilenameForChunk functor to get the filename or function
+	 * @param {(chunk: Chunk) => TemplatePath | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -138,7 +138,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			};
 			/**
 			 * @param {string} value string
-			 * @returns {function(number): string} string to put in quotes with length
+			 * @returns {(length: number) => string} string to put in quotes with length
 			 */
 			const unquotedStringifyWithLength = value => length =>
 				unquotedStringify(`${value}`.slice(0, length));
@@ -191,7 +191,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		}
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn
 		 */
 		const createMap = fn => {
@@ -225,14 +225,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		};
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn for including in quoted string
 		 */
 		const mapExpr = fn => `" + ${createMap(fn)} + "`;
 
 		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+		 * @param {(chunk: Chunk) => string | number} fn function from chunk to value
+		 * @returns {(length: number) => string} function which generates code with static mapping of results of fn for including in quoted string for specific length
 		 */
 		const mapExprWithLength = fn => length =>
 			`" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;

package/lib/schemes/HttpUriPlugin.js

@@ -32,7 +32,7 @@ const getHttps = memoize(() => require("https"));
 /**
  * @param {typeof import("http") | typeof import("https")} request request
  * @param {string | { toString: () => string } | undefined} proxy proxy
- * @returns {function(URL, RequestOptions, function(IncomingMessage): void): EventEmitter} fn
+ * @returns {(url: URL, requestOptions: RequestOptions, callback: (incomingMessage: IncomingMessage) => void) => EventEmitter} fn
  */
 const proxyFetch = (request, proxy) => (url, options, callback) => {
 	const eventEmitter = new EventEmitter();
@@ -255,8 +255,18 @@ class Lockfile {
 
 /**
  * @template R
- * @param {function(function(Error | null, R=): void): void} fn function
- * @returns {function(function(Error | null, R=): void): void} cached function
+ * @typedef {(err: Error | null, result?: R) => void}  FnWithoutKeyCallback
+ */
+
+/**
+ * @template R
+ * @typedef {(callback: FnWithoutKeyCallback<R>) => void} FnWithoutKey
+ */
+
+/**
+ * @template R
+ * @param {FnWithoutKey<R>} fn function
+ * @returns {FnWithoutKey<R>} cached function
  */
 const cachedWithoutKey = fn => {
 	let inFlight = false;
@@ -264,7 +274,7 @@ const cachedWithoutKey = fn => {
 	let cachedError;
 	/** @type {R | undefined} */
 	let cachedResult;
-	/** @type {(function(Error| null, R=): void)[] | undefined} */
+	/** @type {FnWithoutKeyCallback<R>[] | undefined} */
 	let cachedCallbacks;
 	return callback => {
 		if (inFlight) {
@@ -286,23 +296,34 @@ const cachedWithoutKey = fn => {
 	};
 };
 
+/**
+ * @template R
+ * @typedef {(err: Error | null, result?: R) => void} FnWithKeyCallback
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(item: T, callback: FnWithKeyCallback<R>) => void} FnWithKey
+ */
+
 /**
  * @template T
  * @template R
- * @param {function(T, function(Error | null, R=): void): void} fn function
- * @param {function(T, function(Error | null, R=): void): void=} forceFn function for the second try
- * @returns {(function(T, function(Error | null, R=): void): void) & { force: function(T, function(Error | null, R=): void): void }} cached function
+ * @param {FnWithKey<T, R>} fn function
+ * @param {FnWithKey<T, R>=} forceFn function for the second try
+ * @returns {(FnWithKey<T, R>) & { force: FnWithKey<T, R> }} cached function
  */
 const cachedWithKey = (fn, forceFn = fn) => {
 	/**
 	 * @template R
-	 * @typedef {{ result?: R, error?: Error, callbacks?: (function(Error | null, R=): void)[], force?: true }} CacheEntry
+	 * @typedef {{ result?: R, error?: Error, callbacks?: FnWithKeyCallback<R>[], force?: true }} CacheEntry
 	 */
 	/** @type {Map<T, CacheEntry<R>>} */
 	const cache = new Map();
 	/**
 	 * @param {T} arg arg
-	 * @param {function(Error | null, R=): void} callback callback
+	 * @param {FnWithKeyCallback<R>} callback callback
 	 * @returns {void}
 	 */
 	const resultFn = (arg, callback) => {
@@ -333,7 +354,7 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	};
 	/**
 	 * @param {T} arg arg
-	 * @param {function(Error | null, R=): void} callback callback
+	 * @param {FnWithKeyCallback<R>} callback callback
 	 * @returns {void}
 	 */
 	resultFn.force = (arg, callback) => {
@@ -487,7 +508,7 @@ class HttpUriPlugin {
 
 				const getLockfile = cachedWithoutKey(
 					/**
-					 * @param {function(Error | null, Lockfile=): void} callback callback
+					 * @param {(err: Error | null, lockfile?: Lockfile) => void} callback callback
 					 * @returns {void}
 					 */
 					callback => {
@@ -581,7 +602,7 @@ class HttpUriPlugin {
 				 * @param {Lockfile} lockfile lockfile
 				 * @param {string} url url
 				 * @param {ResolveContentResult} result result
-				 * @param {function(Error | null, ResolveContentResult=): void} callback callback
+				 * @param {(err: Error | null, result?: ResolveContentResult) => void} callback callback
 				 * @returns {void}
 				 */
 				const storeResult = (lockfile, url, result, callback) => {
@@ -608,7 +629,7 @@ class HttpUriPlugin {
 					/**
 					 * @param {string} url URL
 					 * @param {string | null} integrity integrity
-					 * @param {function(Error | null, ResolveContentResult=): void} callback callback
+					 * @param {(err: Error | null, resolveContentResult?: ResolveContentResult) => void} callback callback
 					 */
 					const resolveContent = (url, integrity, callback) => {
 						/**
@@ -654,7 +675,7 @@ class HttpUriPlugin {
 					/**
 					 * @param {string} url URL
 					 * @param {FetchResult | RedirectFetchResult | undefined} cachedResult result from cache
-					 * @param {function(Error | null, FetchResult=): void} callback callback
+					 * @param {(err: Error | null, fetchResult?: FetchResult) => void} callback callback
 					 * @returns {void}
 					 */
 					const fetchContentRaw = (url, cachedResult, callback) => {
@@ -826,7 +847,7 @@ class HttpUriPlugin {
 					const fetchContent = cachedWithKey(
 						/**
 						 * @param {string} url URL
-						 * @param {function(Error | null, { 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?: { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }) => void} callback callback
 						 * @returns {void}
 						 */
 						(url, callback) => {
@@ -864,7 +885,7 @@ class HttpUriPlugin {
 					const getInfo = cachedWithKey(
 						/**
 						 * @param {string} url the url
-						 * @param {function(Error | null, Info=): void} callback callback
+						 * @param {(err: Error | null, info?: Info) => void} callback callback
 						 * @returns {void}
 						 */
 						// eslint-disable-next-line no-loop-func
@@ -1113,7 +1134,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					/**
 					 * @param {URL} url url
 					 * @param {ResourceDataWithData} resourceData resource data
-					 * @param {function(Error | null, true | void): void} callback callback
+					 * @param {(err: Error | null, result: true | void) => void} callback callback
 					 */
 					const respondWithUrlModule = (url, resourceData, callback) => {
 						getInfo(url.href, (err, _result) => {

package/lib/serialization/BinaryMiddleware.js

@@ -7,9 +7,15 @@
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
+/** @typedef {import("./SerializerMiddleware").Context} Context */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
+/**
+ * @template LAZY_RESULT
+ * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
+ */
+
 /*
 Format:
 
@@ -135,8 +141,6 @@ const identifyBigInt = n => {
 	return 2;
 };
 
-/** @typedef {TODO} Context */
-
 /**
  * @typedef {PrimitiveSerializableType[]} DeserializedType
  * @typedef {BufferSerializableType[]} SerializedType
@@ -145,17 +149,17 @@ const identifyBigInt = n => {
 class BinaryMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		return this._serialize(data, context);
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {TODO} context serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @param {LazyFunction<DeserializedType>} fn lazy function
+	 * @param {Context} context serialize function
+	 * @returns {LazyFunction<SerializedType>} new lazy
 	 */
 	_serializeLazy(fn, context) {
 		return SerializerMiddleware.serializeLazy(fn, data =>
@@ -165,7 +169,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {TODO} context context object
+	 * @param {Context} context context object
 	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
 	 * @returns {SerializedType} serialized data
 	 */
@@ -277,7 +281,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				case "function": {
 					if (!SerializerMiddleware.isLazy(thing))
 						throw new Error(`Unexpected function ${thing}`);
-					/** @type {SerializedType | (() => SerializedType)} */
+					/** @type {SerializedType | LazyFunction<SerializedType>} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
 					if (serializedData === undefined) {
@@ -285,16 +289,23 @@ class BinaryMiddleware extends SerializerMiddleware {
 							flush();
 							allocationScope.leftOverBuffer = leftOverBuffer;
 							const result =
-								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
-									thing()
-								);
+								/** @type {PrimitiveSerializableType[]} */
+								(thing());
 							const data = this._serialize(result, context, allocationScope);
 							leftOverBuffer = allocationScope.leftOverBuffer;
 							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(thing, data);
+							SerializerMiddleware.setLazySerializedValue(
+								/** @type {LazyFunction<DeserializedType>} */
+								(thing),
+								data
+							);
 							serializedData = data;
 						} else {
-							serializedData = this._serializeLazy(thing, context);
+							serializedData = this._serializeLazy(
+								/** @type {LazyFunction<DeserializedType>} */
+								(thing),
+								context
+							);
 							flush();
 							buffers.push(serializedData);
 							break;
@@ -644,13 +655,19 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		return this._deserialize(data, context);
 	}
 
+	/**
+	 * @private
+	 * @param {SerializedType} content content
+	 * @param {Context} context context object
+	 * @returns {LazyFunction<DeserializedType>} lazy function
+	 */
 	_createLazyDeserialized(content, context) {
 		return SerializerMiddleware.createLazy(
 			memoize(() => this._deserialize(content, context)),
@@ -660,6 +677,12 @@ class BinaryMiddleware extends SerializerMiddleware {
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {LazyFunction<SerializedType>} fn lazy function
+	 * @param {Context} context context object
+	 * @returns {LazyFunction<DeserializedType>} new lazy
+	 */
 	_deserializeLazy(fn, context) {
 		return SerializerMiddleware.deserializeLazy(fn, data =>
 			this._deserialize(data, context)
@@ -668,7 +691,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {TODO} context context object
+	 * @param {Context} context context object
 	 * @returns {DeserializedType} deserialized data
 	 */
 	_deserialize(data, context) {
@@ -795,13 +818,17 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						const count = readU32();
 						const lengths = Array.from({ length: count }).map(() => readU32());
+						/** @type {(Buffer | LazyFunction<BufferSerializableType[]>)[]} */
 						const content = [];
 						for (let l of lengths) {
 							if (l === 0) {
 								if (typeof currentBuffer !== "function") {
 									throw new Error("Unexpected non-lazy element in stream");
 								}
-								content.push(currentBuffer);
+								content.push(
+									/** @type {LazyFunction<BufferSerializableType[]>} */
+									(currentBuffer)
+								);
 								currentDataItem++;
 								currentBuffer =
 									currentDataItem < data.length ? data[currentDataItem] : null;
@@ -1117,7 +1144,13 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let result = [];
 		while (currentBuffer !== null) {
 			if (typeof currentBuffer === "function") {
-				result.push(this._deserializeLazy(currentBuffer, context));
+				result.push(
+					this._deserializeLazy(
+						/** @type {LazyFunction<SerializedType>} */
+						(currentBuffer),
+						context
+					)
+				);
 				currentDataItem++;
 				currentBuffer =
 					currentDataItem < data.length ? data[currentDataItem] : null;