webpack 5.97.1 → 5.104.1

package/lib/serialization/ObjectMiddleware.js

@@ -4,7 +4,9 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
+const AggregateErrorSerializer = require("./AggregateErrorSerializer");
 const ArraySerializer = require("./ArraySerializer");
 const DateObjectSerializer = require("./DateObjectSerializer");
 const ErrorObjectSerializer = require("./ErrorObjectSerializer");
@@ -15,11 +17,13 @@ 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").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/** @typedef {new (...params: any[]) => any} Constructor */
+/** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
 /*
 
@@ -43,24 +47,38 @@ Technically any value can be used.
 
 */
 
+/**
+ * @typedef {object} ObjectSerializerSnapshot
+ * @property {number} length
+ * @property {number} cycleStackSize
+ * @property {number} referenceableSize
+ * @property {number} currentPos
+ * @property {number} objectTypeLookupSize
+ * @property {number} currentPosTypeLookup
+ */
+
+/** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
+
 /**
  * @typedef {object} ObjectSerializerContext
- * @property {function(any): void} write
- * @property {(function(any): void)=} writeLazy
- * @property {(function(any, object=): (() => Promise<any> | any))=} writeSeparate
- * @property {function(any): void} setCircularReference
+ * @property {(value: EXPECTED_ANY) => void} write
+ * @property {(value: ReferenceableItem) => void} setCircularReference
+ * @property {() => ObjectSerializerSnapshot} snapshot
+ * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
+ * @property {((item: EXPECTED_ANY | (() => EXPECTED_ANY)) => void)=} writeLazy
+ * @property {((item: (EXPECTED_ANY | (() => EXPECTED_ANY)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
  */
 
 /**
  * @typedef {object} ObjectDeserializerContext
- * @property {function(): any} read
- * @property {function(any): void} setCircularReference
+ * @property {() => EXPECTED_ANY} read
+ * @property {(value: ReferenceableItem) => void} setCircularReference
  */
 
 /**
  * @typedef {object} ObjectSerializer
- * @property {function(any, ObjectSerializerContext): void} serialize
- * @property {function(ObjectDeserializerContext): any} deserialize
+ * @property {(value: EXPECTED_ANY, context: ObjectSerializerContext) => void} serialize
+ * @property {(context: ObjectDeserializerContext) => EXPECTED_ANY} deserialize
  */
 
 /**
@@ -99,7 +117,7 @@ const setMapSize = (map, size) => {
 const toHash = (buffer, hashFunction) => {
 	const hash = createHash(hashFunction);
 	hash.update(buffer);
-	return /** @type {string} */ (hash.digest("latin1"));
+	return hash.digest("latin1");
 };
 
 const ESCAPE = null;
@@ -109,7 +127,10 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 2;
 
-/** @type {Map<Constructor, { request?: string, name?: string | number | null, serializer?: ObjectSerializer }>} */
+/** @typedef {{ request?: string, name?: string | number | null, serializer?: ObjectSerializer }} SerializerConfig */
+/** @typedef {{ request?: string, name?: string | number | null, serializer: ObjectSerializer }} SerializerConfigWithSerializer */
+
+/** @type {Map<Constructor | null, SerializerConfig>} */
 const serializers = new Map();
 /** @type {Map<string | number, ObjectSerializer>} */
 const serializerInversed = new Map();
@@ -119,7 +140,9 @@ const loadedRequests = new Set();
 
 const NOT_SERIALIZABLE = {};
 
+/** @type {Map<Constructor | null, ObjectSerializer>} */
 const jsTypes = new Map();
+
 jsTypes.set(Object, new PlainObjectSerializer());
 jsTypes.set(Array, new ArraySerializer());
 jsTypes.set(null, new NullPrototypeObjectSerializer());
@@ -134,15 +157,24 @@ jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
 jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
 jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 
-// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e. g. when
+// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+if (typeof AggregateError !== "undefined") {
+	jsTypes.set(
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		AggregateError,
+		new AggregateErrorSerializer()
+	);
+}
+
+// If in a sandboxed environment (e.g. jest), this escapes the sandbox and registers
+// real Object and Array types to. These types may occur in the wild too, e.g. when
 // using Structured Clone in postMessage.
 // eslint-disable-next-line n/exports-style
 if (exports.constructor !== Object) {
-	// eslint-disable-next-line jsdoc/check-types, n/exports-style
-	const Obj = /** @type {typeof Object} */ (exports.constructor);
-	const Fn = /** @type {typeof Function} */ (Obj.constructor);
-	for (const [type, config] of Array.from(jsTypes)) {
+	// eslint-disable-next-line n/exports-style
+	const Obj = /** @type {ObjectConstructor} */ (exports.constructor);
+	const Fn = /** @type {FunctionConstructor} */ (Obj.constructor);
+	for (const [type, config] of jsTypes) {
 		if (type) {
 			const Type = new Fn(`return ${type.name};`)();
 			jsTypes.set(Type, config);
@@ -171,17 +203,19 @@ 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 {
 	/**
-	 * @param {function(any): void} extendContext context extensions
+	 * @param {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} extendContext context extensions
 	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(extendContext, hashFunction = "md4") {
+	constructor(extendContext, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
 		this.extendContext = extendContext;
 		this._hashFunction = hashFunction;
@@ -189,7 +223,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {RegExp} regExp RegExp for which the request is tested
-	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
+	 * @param {(request: string) => boolean} loader loader to load the request, returns true when successful
 	 * @returns {void}
 	 */
 	static registerLoader(regExp, loader) {
@@ -241,6 +275,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		serializers.set(Constructor, NOT_SERIALIZABLE);
 	}
 
+	/**
+	 * @param {Constructor} object for serialization
+	 * @returns {SerializerConfigWithSerializer} Serializer config
+	 */
 	static getSerializerFor(object) {
 		const proto = Object.getPrototypeOf(object);
 		let c;
@@ -260,12 +298,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 		if (!config) throw new Error(`No serializer registered for ${c.name}`);
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
-		return config;
+		return /** @type {SerializerConfigWithSerializer} */ (config);
 	}
 
 	/**
 	 * @param {string} request request
-	 * @param {TODO} name name
+	 * @param {string} name name
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static getDeserializerFor(request, name) {
@@ -292,15 +330,19 @@ class ObjectMiddleware 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) {
-		/** @type {any[]} */
+		/** @type {PrimitiveSerializableType[]} */
 		let result = [CURRENT_VERSION];
 		let currentPos = 0;
+		/** @type {Map<ReferenceableItem, number>} */
 		let referenceable = new Map();
-		const addReferenceable = item => {
+		/**
+		 * @param {ReferenceableItem} item referenceable item
+		 */
+		const addReferenceable = (item) => {
 			referenceable.set(item, currentPos++);
 		};
 		let bufferDedupeMap = new Map();
@@ -308,7 +350,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		 * @param {Buffer} buf buffer
 		 * @returns {Buffer} deduped buffer
 		 */
-		const dedupeBuffer = buf => {
+		const dedupeBuffer = (buf) => {
 			const len = buf.length;
 			const entry = bufferDedupeMap.get(len);
 			if (entry === undefined) {
@@ -368,11 +410,15 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
-		const stackToString = item => {
-			const arr = Array.from(cycleStack);
+		/**
+		 * @param {ComplexSerializableType} item item to stack
+		 * @returns {string} stack
+		 */
+		const stackToString = (item) => {
+			const arr = [...cycleStack];
 			arr.push(item);
 			return arr
-				.map(item => {
+				.map((item) => {
 					if (typeof item === "string") {
 						if (item.length > 100) {
 							return `String ${JSON.stringify(item.slice(0, 100)).slice(
@@ -392,11 +438,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 					if (typeof item === "object" && item !== null) {
 						if (item.constructor) {
-							if (item.constructor === Object)
+							if (item.constructor === Object) {
 								return `Object { ${Object.keys(item).join(", ")} }`;
+							}
 							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array)
+							if (item.constructor === Array) {
 								return `Array { ${item.length} items }`;
+							}
 							if (item.constructor === Set) return `Set { ${item.size} items }`;
 							if (item.constructor === RegExp) return item.toString();
 							return `${item.constructor.name}`;
@@ -411,21 +459,23 @@ class ObjectMiddleware extends SerializerMiddleware {
 					try {
 						return `${item}`;
 					} catch (err) {
-						return `(${err.message})`;
+						return `(${/** @type {Error} */ (err).message})`;
 					}
 				})
 				.join(" -> ");
 		};
 		/** @type {WeakSet<Error>} */
 		let hasDebugInfoAttached;
+		/** @type {ObjectSerializerContext} */
 		let ctx = {
-			write(value, key) {
+			write(value) {
 				try {
 					process(value);
 				} catch (err) {
 					if (err !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined)
+						if (hasDebugInfoAttached === undefined) {
 							hasDebugInfoAttached = new WeakSet();
+						}
 						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
 							/** @type {Error} */
 							(err).message += `\nwhile serializing ${stackToString(value)}`;
@@ -459,7 +509,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
-		const process = item => {
+		/**
+		 * @param {ComplexSerializableType} item item to serialize
+		 */
+		const process = (item) => {
 			if (Buffer.isBuffer(item)) {
 				// check if we can emit a reference
 				const ref = referenceable.get(item);
@@ -479,7 +532,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				}
 				addReferenceable(item);
 
-				result.push(item);
+				result.push(/** @type {Buffer} */ (item));
 			} else if (item === ESCAPE) {
 				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
 			} else if (
@@ -499,8 +552,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				}
 
-				const { request, name, serializer } =
-					ObjectMiddleware.getSerializerFor(item);
+				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
+					/** @type {Constructor} */
+					(item)
+				);
 				const key = `${request}/${name}`;
 				const lastIndex = objectTypeLookup.get(key);
 
@@ -545,11 +600,14 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 				result.push(item);
 			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item))
+				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);
@@ -559,9 +617,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 				} else if (SerializerMiddleware.isLazy(item, this)) {
 					throw new Error("Not implemented");
 				} else {
-					const data = SerializerMiddleware.serializeLazy(item, data =>
-						this.serialize([data], context)
-					);
+					const data =
+						/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
+						(
+							SerializerMiddleware.serializeLazy(item, (data) =>
+								this.serialize([data], context)
+							)
+						);
 					SerializerMiddleware.setLazySerializedValue(item, data);
 					result.push(data);
 				}
@@ -599,30 +661,39 @@ class ObjectMiddleware 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) {
 		let currentDataPos = 0;
 		const read = () => {
-			if (currentDataPos >= data.length)
+			if (currentDataPos >= data.length) {
 				throw new Error("Unexpected end of stream");
+			}
 
 			return data[currentDataPos++];
 		};
 
-		if (read() !== CURRENT_VERSION)
+		if (read() !== CURRENT_VERSION) {
 			throw new Error("Version mismatch, serializer changed");
+		}
 
 		let currentPos = 0;
+		/** @type {ReferenceableItem[]} */
 		let referenceable = [];
-		const addReferenceable = item => {
+		/**
+		 * @param {ReferenceableItem} item referenceable item
+		 */
+		const addReferenceable = (item) => {
 			referenceable.push(item);
 			currentPos++;
 		};
 		let currentPosTypeLookup = 0;
+		/** @type {ObjectSerializer[]} */
 		let objectTypeLookup = [];
+		/** @type {ComplexSerializableType[]} */
 		let result = [];
+		/** @type {ObjectDeserializerContext} */
 		let ctx = {
 			read() {
 				return decodeValue();
@@ -633,6 +704,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		/**
+		 * @returns {ComplexSerializableType} deserialize value
+		 */
 		const decodeValue = () => {
 			const item = read();
 
@@ -724,7 +798,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						const name = !serializerEntry
 							? "unknown"
 							: !serializerEntry[1].request
-								? serializerEntry[0].name
+								? /** @type {Constructor[]} */ (serializerEntry)[0].name
 								: serializerEntry[1].name
 									? `${serializerEntry[1].request} ${serializerEntry[1].name}`
 									: serializerEntry[1].request;
@@ -746,7 +820,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			} else if (typeof item === "function") {
 				return SerializerMiddleware.deserializeLazy(
 					item,
-					data => this.deserialize(data, context)[0]
+					(data) =>
+						/** @type {[DeserializedType]} */
+						(this.deserialize(data, context))[0]
 				);
 			} else {
 				return item;

package/lib/serialization/PlainObjectSerializer.js

@@ -7,7 +7,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
-/** @typedef {(arg0?: any) => void} CacheAssoc */
+/** @typedef {EXPECTED_FUNCTION} CacheAssoc */
 
 /**
  * @template T

package/lib/serialization/Serializer.js

@@ -5,59 +5,77 @@
 "use strict";
 
 /**
- * @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 {TODO=} context context
+	 * @param {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>[]} middlewares serializer middlewares
+	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
-		this.serializeMiddlewares = middlewares.slice();
-		this.deserializeMiddlewares = middlewares.slice().reverse();
+		this.serializeMiddlewares = [...middlewares];
+		this.deserializeMiddlewares = [...middlewares].reverse();
 		this.context = context;
 	}
 
 	/**
-	 * @param {any} obj object
-	 * @param {TODO} context content
-	 * @returns {Promise<any>} 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") {
-				current = current.then(data => data && middleware.serialize(data, ctx));
+			if (
+				current &&
+				typeof (/** @type {Promise<DeserializedValue>} */ (current).then) ===
+					"function"
+			) {
+				current =
+					/** @type {Promise<DeserializedValue>} */
+					(current).then((data) => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
 					current = middleware.serialize(current, ctx);
 				} catch (err) {
 					current = Promise.reject(err);
 				}
-			} else break;
+			} else {
+				break;
+			}
 		}
-		return current;
+		return /** @type {Promise<SerializedValue>} */ (current);
 	}
 
 	/**
-	 * @param {any} value value
-	 * @param {TODO} context context
-	 * @returns {Promise<any>} 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 };
-		/** @type {any} */
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			current =
-				current && typeof current.then === "function"
-					? current.then(data => middleware.deserialize(data, ctx))
+				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);
 	}
 }