webpack 5.99.5 → 5.99.6

package/lib/serialization/ObjectMiddleware.js

@@ -16,18 +16,14 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
+/** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("./SerializerMiddleware").Context} Context */
+/** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
-/**
- * @template LAZY_RESULT
- * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
- */
-
 /*
 
 Format:
@@ -59,27 +55,29 @@ Technically any value can be used.
  * @property {number} objectTypeLookupSize
  * @property {number} currentPosTypeLookup
  */
+/** @typedef {TODO} Value */
+/** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
 
 /**
  * @typedef {object} ObjectSerializerContext
- * @property {(value: any) => void} write
- * @property {(value: any) => void} setCircularReference
+ * @property {(value: Value) => void} write
+ * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
- * @property {((item: any) => void)=} writeLazy
- * @property {((item: any, obj?: TODO) => (() => Promise<any> | any))=} writeSeparate
+ * @property {((item: Value | (() => Value)) => void)=} writeLazy
+ * @property {((item: (Value | (() => Value)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
  */
 
 /**
  * @typedef {object} ObjectDeserializerContext
- * @property {() => any} read
- * @property {(value: any) => void} setCircularReference
+ * @property {() => Value} read
+ * @property {(value: ReferenceableItem) => void} setCircularReference
  */
 
 /**
  * @typedef {object} ObjectSerializer
- * @property {(value: any, context: ObjectSerializerContext) => void} serialize
- * @property {(context: ObjectDeserializerContext) => any} deserialize
+ * @property {(value: Value, context: ObjectSerializerContext) => void} serialize
+ * @property {(context: ObjectDeserializerContext) => Value} deserialize
  */
 
 /**
@@ -141,8 +139,6 @@ const loadedRequests = new Set();
 
 const NOT_SERIALIZABLE = {};
 
-/** @typedef {TODO} Item */
-
 const jsTypes = new Map();
 jsTypes.set(Object, new PlainObjectSerializer());
 jsTypes.set(Array, new ArraySerializer());
@@ -195,10 +191,12 @@ for (const { request, name, serializer } of serializers.values()) {
 /** @type {Map<RegExp, (request: string) => boolean>} */
 const loaders = new Map();
 
+/** @typedef {ComplexSerializableType[]} DeserializedType */
+/** @typedef {PrimitiveSerializableType[]} SerializedType */
+/** @typedef {{ logger: Logger }} Context */
+
 /**
- * @typedef {ComplexSerializableType[]} DeserializedType
- * @typedef {PrimitiveSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
@@ -266,7 +264,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {TODO} object for serialization
+	 * @param {Constructor} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
@@ -324,13 +322,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		/** @type {Item[]} */
+		/** @type {Value[]} */
 		let result = [CURRENT_VERSION];
 		let currentPos = 0;
-		/** @type {Map<Item, number>} */
+		/** @type {Map<ReferenceableItem, number>} */
 		let referenceable = new Map();
 		/**
-		 * @param {Item} item referenceable item
+		 * @param {ReferenceableItem} item referenceable item
 		 */
 		const addReferenceable = item => {
 			referenceable.set(item, currentPos++);
@@ -401,7 +399,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
 		/**
-		 * @param {Item} item item to stack
+		 * @param {Value} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = item => {
@@ -497,7 +495,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		/**
-		 * @param {Item} item item to serialize
+		 * @param {Value} item item to serialize
 		 */
 		const process = item => {
 			if (Buffer.isBuffer(item)) {
@@ -587,9 +585,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 			} else if (typeof item === "function") {
 				if (!SerializerMiddleware.isLazy(item))
 					throw new Error(`Unexpected function ${item}`);
-				/** @type {SerializedType} */
+
+				/** @type {SerializedType | undefined} */
 				const serializedData =
 					SerializerMiddleware.getLazySerializedValue(item);
+
 				if (serializedData !== undefined) {
 					if (typeof serializedData === "function") {
 						result.push(serializedData);
@@ -655,10 +655,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 			throw new Error("Version mismatch, serializer changed");
 
 		let currentPos = 0;
-		/** @type {Item[]} */
+		/** @type {ReferenceableItem[]} */
 		let referenceable = [];
 		/**
-		 * @param {Item} item referenceable item
+		 * @param {Value} item referenceable item
 		 */
 		const addReferenceable = item => {
 			referenceable.push(item);
@@ -791,8 +791,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				return item;
 			} else if (typeof item === "function") {
 				return SerializerMiddleware.deserializeLazy(
-					/** @type {LazyFunction<SerializedType>} */
-					(item),
+					item,
 					data =>
 						/** @type {[DeserializedType]} */
 						(this.deserialize(data, context))[0]

package/lib/serialization/Serializer.js

@@ -4,17 +4,20 @@
 
 "use strict";
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
-
 /**
- * @template T, K
- * @typedef {import("./SerializerMiddleware")<T, K>} SerializerMiddleware
+ * @template T, K, C
+ * @typedef {import("./SerializerMiddleware")<T, K, C>} SerializerMiddleware
  */
 
+/**
+ * @template DeserializedValue
+ * @template SerializedValue
+ * @template Context
+ */
 class Serializer {
 	/**
-	 * @param {SerializerMiddleware<any, any>[]} middlewares serializer middlewares
-	 * @param {Context} [context] context
+	 * @param {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>[]} middlewares serializer middlewares
+	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
 		this.serializeMiddlewares = middlewares.slice();
@@ -23,17 +26,22 @@ class Serializer {
 	}
 
 	/**
-	 * @param {TODO | Promise<TODO>} obj object
-	 * @param {Context} context context object
-	 * @returns {Promise<TODO>} result
+	 * @template ExtendedContext
+	 * @param {DeserializedValue | Promise<DeserializedValue>} obj object
+	 * @param {Context & ExtendedContext} context context object
+	 * @returns {Promise<SerializedValue>} result
 	 */
 	serialize(obj, context) {
 		const ctx = { ...context, ...this.context };
 		let current = obj;
 		for (const middleware of this.serializeMiddlewares) {
-			if (current && typeof current.then === "function") {
+			if (
+				current &&
+				typeof (/** @type {Promise<DeserializedValue>} */ (current).then) ===
+					"function"
+			) {
 				current =
-					/** @type {Promise<TODO>} */
+					/** @type {Promise<DeserializedValue>} */
 					(current).then(data => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
@@ -43,26 +51,29 @@ class Serializer {
 				}
 			} else break;
 		}
-		return current;
+		return /** @type {Promise<SerializedValue>} */ (current);
 	}
 
 	/**
-	 * @param {TODO | Promise<TODO>} value value
-	 * @param {Context} context object
-	 * @returns {Promise<TODO>} result
+	 * @template ExtendedContext
+	 * @param {SerializedValue | Promise<SerializedValue>} value value
+	 * @param {Context & ExtendedContext} context object
+	 * @returns {Promise<DeserializedValue>} result
 	 */
 	deserialize(value, context) {
 		const ctx = { ...context, ...this.context };
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			current =
-				current && typeof current.then === "function"
-					? /** @type {Promise<TODO>} */ (current).then(data =>
+				current &&
+				typeof (/** @type {Promise<SerializedValue>} */ (current).then) ===
+					"function"
+					? /** @type {Promise<SerializedValue>} */ (current).then(data =>
 							middleware.deserialize(data, ctx)
 						)
 					: middleware.deserialize(current, ctx);
 		}
-		return current;
+		return /** @type {Promise<DeserializedValue>} */ (current);
 	}
 }
 

package/lib/serialization/SerializerMiddleware.js

@@ -9,23 +9,21 @@ const memoize = require("../util/memoize");
 const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
-/** @typedef {TODO} Context */
+/** @typedef {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, Record<string, EXPECTED_ANY>>} LazyTarget */
+/** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
 
 /**
- * @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 InputValue
+ * @template OutputValue
+ * @template {LazyTarget} InternalLazyTarget
+ * @template {LazyOptions | undefined} InternalLazyOptions
+ * @typedef {(() => InputValue | Promise<InputValue>) & Partial<{ [LAZY_TARGET]: InternalLazyTarget, options: InternalLazyOptions, [LAZY_SERIALIZED_VALUE]?: OutputValue | LazyFunction<OutputValue, InputValue, InternalLazyTarget, InternalLazyOptions> | undefined }>} LazyFunction
  */
 
 /**
  * @template DeserializedType
  * @template SerializedType
+ * @template Context
  */
 class SerializerMiddleware {
 	/* istanbul ignore next */
@@ -53,17 +51,25 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {LazyOptions=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {LazyFunction<LazyResult>} lazy function
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {TLazyInputValue | (() => TLazyInputValue)} value contained value or function to value
+	 * @param {TLazyTarget} target target middleware
+	 * @param {TLazyOptions=} options lazy options
+	 * @param {TLazyOutputValue=} serializedValue serialized value
+	 * @returns {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy function
 	 */
-	static createLazy(value, target, options = {}, serializedValue = undefined) {
+	static createLazy(
+		value,
+		target,
+		options = /** @type {TLazyOptions} */ ({}),
+		serializedValue = undefined
+	) {
 		if (SerializerMiddleware.isLazy(value, target)) return value;
 		const fn =
-			/** @type {LazyFunction<LazyResult>} */
+			/** @type {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} */
 			(typeof value === "function" ? value : () => value);
 		fn[LAZY_TARGET] = target;
 		fn.options = options;
@@ -72,9 +78,10 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * @template {LazyTarget} TLazyTarget
 	 * @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)
+	 * @param {TLazyTarget=} target target middleware
+	 * @returns {fn is LazyFunction<EXPECTED_ANY, EXPECTED_ANY, TLazyTarget, EXPECTED_ANY>} true, when fn is a lazy function (optionally of that target)
 	 */
 	static isLazy(fn, target) {
 		if (typeof fn !== "function") return false;
@@ -83,19 +90,26 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult>} fn lazy function
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
+	 * @template TLazySerializedValue
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @returns {LazyOptions | undefined} options
 	 */
 	static getLazyOptions(fn) {
 		if (typeof fn !== "function") return;
-		return /** @type {any} */ (fn).options;
+		return fn.options;
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} fn lazy function
-	 * @returns {any | undefined} serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions> | EXPECTED_ANY} fn lazy function
+	 * @returns {TLazyOutputValue | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
 		if (typeof fn !== "function") return;
@@ -103,9 +117,12 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult>} fn lazy function
-	 * @param {TODO} value serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, LazyTarget, LazyOptions>} fn lazy function
+	 * @param {TLazyOutputValue} value serialized value
 	 * @returns {void}
 	 */
 	static setLazySerializedValue(fn, value) {
@@ -113,27 +130,33 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult, R
-	 * @param {LazyFunction<LazyResult>} lazy lazy function
-	 * @param {(lazyResult: LazyResult) => Promise<R> | R} serialize serialize function
-	 * @returns {LazyFunction<R>} new lazy
+	 * @template TLazyInputValue DeserializedValue
+	 * @template TLazyOutputValue SerializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(value: TLazyInputValue) => TLazyOutputValue} serialize serialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static serializeLazy(lazy, serialize) {
-		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));
-			})
-		);
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */
+			(
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then(data => data && serialize(data))
+						);
+					}
+					return serialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;
 		lazy[LAZY_SERIALIZED_VALUE] = fn;
@@ -141,27 +164,33 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult, R
-	 * @param {LazyFunction<LazyResult>} lazy lazy function
-	 * @param {(lazyResult: LazyResult) => Promise<R> | R} deserialize deserialize function
-	 * @returns {LazyFunction<R>} new lazy
+	 * @template TLazyInputValue SerializedValue
+	 * @template TLazyOutputValue DeserializedValue
+	 * @template SerializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(data: TLazyInputValue) => TLazyOutputValue} deserialize deserialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static deserializeLazy(lazy, deserialize) {
-		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));
-			})
-		);
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */ (
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then(data => deserialize(data))
+						);
+					}
+					return deserialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;
 		fn[LAZY_SERIALIZED_VALUE] = lazy;
@@ -169,20 +198,24 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} lazy lazy function
-	 * @returns {LazyFunction<LazyResult> | EXPECTED_ANY} new lazy
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} lazy lazy function
+	 * @returns {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} new lazy
 	 */
 	static unMemoizeLazy(lazy) {
 		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
-		/** @type {LazyFunction<LazyResult>} */
+		/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
 		const fn = () => {
 			throw new Error(
 				"A lazy value that has been unmemorized can't be called again"
 			);
 		};
 		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
+			/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
+			(lazy[LAZY_SERIALIZED_VALUE])
 		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;

package/lib/serialization/SingleItemMiddleware.js

@@ -6,13 +6,12 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
-
-/** @typedef {any} DeserializedType */
-/** @typedef {any[]} SerializedType */
+/** @typedef {EXPECTED_ANY} DeserializedType */
+/** @typedef {EXPECTED_ANY[]} SerializedType */
+/** @typedef {{}} Context */
 
 /**
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class SingleItemMiddleware extends SerializerMiddleware {
 	/**