webpack 5.97.1 → 5.99.0

package/lib/serialization/SerializerMiddleware.js

@@ -9,6 +9,20 @@ const memoize = require("../util/memoize");
 const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
+/** @typedef {TODO} Context */
+
+/**
+ * @template LazyResult
+ * @typedef {() => LazyResult | Promise<LazyResult>} InternalLazyFunction
+ */
+
+/** @typedef {Record<string, any>} LazyOptions */
+
+/**
+ * @template LazyResult
+ * @typedef {InternalLazyFunction<LazyResult> & { [LAZY_TARGET]: TODO, [LAZY_SERIALIZED_VALUE]?: TODO, options: LazyOptions }} LazyFunction
+ */
+
 /**
  * @template DeserializedType
  * @template SerializedType
@@ -18,8 +32,8 @@ class SerializerMiddleware {
 	/**
 	 * @abstract
 	 * @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) {
 		const AbstractMethodError = require("../AbstractMethodError");
@@ -30,8 +44,8 @@ class SerializerMiddleware {
 	/**
 	 * @abstract
 	 * @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) {
 		const AbstractMethodError = require("../AbstractMethodError");
@@ -39,23 +53,26 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {any | function(): Promise<any> | any} value contained value or function to value
+	 * @template LazyResult
+	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} value contained value or function to value
 	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {object=} options lazy options
+	 * @param {LazyOptions=} options lazy options
 	 * @param {any=} serializedValue serialized value
-	 * @returns {function(): Promise<any> | any} lazy function
+	 * @returns {LazyFunction<LazyResult>} lazy function
 	 */
 	static createLazy(value, target, options = {}, serializedValue = undefined) {
 		if (SerializerMiddleware.isLazy(value, target)) return value;
-		const fn = typeof value === "function" ? value : () => value;
+		const fn =
+			/** @type {LazyFunction<LazyResult>} */
+			(typeof value === "function" ? value : () => value);
 		fn[LAZY_TARGET] = target;
-		/** @type {any} */ (fn).options = options;
+		fn.options = options;
 		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
 		return fn;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {EXPECTED_ANY} fn lazy function
 	 * @param {SerializerMiddleware<any, any>=} target target middleware
 	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
 	 */
@@ -66,8 +83,9 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object | undefined} options
+	 * @template LazyResult
+	 * @param {LazyFunction<LazyResult>} fn lazy function
+	 * @returns {LazyOptions | undefined} options
 	 */
 	static getLazyOptions(fn) {
 		if (typeof fn !== "function") return;
@@ -75,7 +93,8 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @template LazyResult
+	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} fn lazy function
 	 * @returns {any | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
@@ -84,8 +103,9 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {any} value serialized value
+	 * @template LazyResult
+	 * @param {LazyFunction<LazyResult>} fn lazy function
+	 * @param {TODO} value serialized value
 	 * @returns {void}
 	 */
 	static setLazySerializedValue(fn, value) {
@@ -93,50 +113,69 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} serialize serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @template LazyResult, R
+	 * @param {LazyFunction<LazyResult>} lazy lazy function
+	 * @param {(lazyResult: LazyResult) => Promise<R> | R} serialize serialize function
+	 * @returns {LazyFunction<R>} new lazy
 	 */
 	static serializeLazy(lazy, serialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => data && serialize(data));
-			}
-			return serialize(r);
-		});
+		const fn = /** @type {LazyFunction<R>} */ (
+			memoize(() => {
+				const r = lazy();
+				if (
+					r &&
+					typeof (/** @type {Promise<LazyResult>} */ (r).then) === "function"
+				) {
+					return (
+						/** @type {Promise<LazyResult>} */
+						(r).then(data => data && serialize(data))
+					);
+				}
+				return serialize(/** @type {LazyResult} */ (r));
+			})
+		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		lazy[LAZY_SERIALIZED_VALUE] = fn;
 		return fn;
 	}
 
 	/**
-	 * @template T
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(T): Promise<T> | T} deserialize deserialize function
-	 * @returns {function(): Promise<T> | T} new lazy
+	 * @template LazyResult, R
+	 * @param {LazyFunction<LazyResult>} lazy lazy function
+	 * @param {(lazyResult: LazyResult) => Promise<R> | R} deserialize deserialize function
+	 * @returns {LazyFunction<R>} new lazy
 	 */
 	static deserializeLazy(lazy, deserialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => deserialize(data));
-			}
-			return deserialize(r);
-		});
+		const fn = /** @type {LazyFunction<R>} */ (
+			memoize(() => {
+				const r = lazy();
+				if (
+					r &&
+					typeof (/** @type {Promise<LazyResult>} */ (r).then) === "function"
+				) {
+					return (
+						/** @type {Promise<LazyResult>} */
+						(r).then(data => deserialize(data))
+					);
+				}
+				return deserialize(/** @type {LazyResult} */ (r));
+			})
+		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		fn[LAZY_SERIALIZED_VALUE] = lazy;
 		return fn;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @template LazyResult
+	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} lazy lazy function
+	 * @returns {LazyFunction<LazyResult> | EXPECTED_ANY} new lazy
 	 */
 	static unMemoizeLazy(lazy) {
 		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
+		/** @type {LazyFunction<LazyResult>} */
 		const fn = () => {
 			throw new Error(
 				"A lazy value that has been unmemorized can't be called again"
@@ -146,7 +185,7 @@ class SerializerMiddleware {
 			lazy[LAZY_SERIALIZED_VALUE]
 		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		fn.options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		return fn;
 	}
 }

package/lib/serialization/SingleItemMiddleware.js

@@ -6,16 +6,19 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
+/** @typedef {import("./SerializerMiddleware").Context} Context */
+
+/** @typedef {any} DeserializedType */
+/** @typedef {any[]} SerializedType */
+
 /**
- * @typedef {any} DeserializedType
- * @typedef {any[]} SerializedType
- * @extends {SerializerMiddleware<any, any[]>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
 class SingleItemMiddleware 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 [data];
@@ -23,8 +26,8 @@ class SingleItemMiddleware 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 data[0];

package/lib/serialization/types.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {undefined | null | number | string | boolean | Buffer | object | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
+/** @typedef {undefined | null | number | string | boolean | Buffer | EXPECTED_OBJECT | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
 
 /** @typedef {undefined | null | number | bigint | string | boolean | Buffer | (() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
 

package/lib/sharing/ConsumeSharedModule.js

@@ -22,9 +22,11 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -115,7 +117,7 @@ class ConsumeSharedModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -127,7 +129,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {

package/lib/sharing/ProvideSharedModule.js

@@ -18,9 +18,11 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -77,7 +79,7 @@ class ProvideSharedModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -89,7 +91,7 @@ class ProvideSharedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -8,18 +8,20 @@
 const ModuleFactory = require("../ModuleFactory");
 const ProvideSharedModule = require("./ProvideSharedModule");
 
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
 
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
-		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
+		const dep =
+			/** @type {ProvideSharedDependency} */
+			(data.dependencies[0]);
 		callback(null, {
 			module: new ProvideSharedModule(
 				dep.shareScope,

package/lib/sharing/utils.js

@@ -326,8 +326,8 @@ module.exports.normalizeVersion = normalizeVersion;
  * @param {InputFileSystem} fs file system
  * @param {string} directory directory to start looking into
  * @param {string[]} descriptionFiles possible description filenames
- * @param {function((Error | null)=, DescriptionFile=, string[]=): void} callback callback
- * @param {function(DescriptionFile=): boolean} satisfiesDescriptionFileData file data compliance check
+ * @param {(err?: Error | null, descriptionFile?: DescriptionFile, paths?: string[]) => void} callback callback
+ * @param {(descriptionFile?: DescriptionFile) => boolean} satisfiesDescriptionFileData file data compliance check
  * @param {Set<string>} checkedFilePaths set of file paths that have been checked
  */
 const getDescriptionFile = (