webpack 5.97.1 → 5.104.1

package/lib/util/cleverMerge.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-/** @type {WeakMap<object, WeakMap<object, object>>} */
+/** @type {WeakMap<EXPECTED_OBJECT, WeakMap<EXPECTED_OBJECT, EXPECTED_OBJECT>>} */
 const mergeCache = new WeakMap();
-/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
+/** @type {WeakMap<EXPECTED_OBJECT, Map<string, Map<string | number | boolean, EXPECTED_OBJECT>>>} */
 const setPropertyCache = new WeakMap();
 const DELETE = Symbol("DELETE");
 const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
@@ -30,10 +30,12 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 const cachedCleverMerge = (first, second) => {
 	if (second === undefined) return /** @type {T} */ (first);
 	if (first === undefined) return /** @type {O} */ (second);
-	if (typeof second !== "object" || second === null)
+	if (typeof second !== "object" || second === null) {
 		return /** @type {O} */ (second);
-	if (typeof first !== "object" || first === null)
+	}
+	if (typeof first !== "object" || first === null) {
 		return /** @type {T} */ (first);
+	}
 
 	let innerCache = mergeCache.get(first);
 	if (innerCache === undefined) {
@@ -44,14 +46,14 @@ const cachedCleverMerge = (first, second) => {
 	if (prevMerge !== undefined) return prevMerge;
 	const newMerge = _cleverMerge(first, second, true);
 	innerCache.set(second, newMerge);
-	return /** @type {T & O} */ (newMerge);
+	return newMerge;
 };
 
 /**
  * @template T
  * @param {Partial<T>} obj object
  * @param {string} property property
- * @param {string|number|boolean} value assignment value
+ * @param {string | number | boolean} value assignment value
  * @returns {T} new object
  */
 const cachedSetProperty = (obj, property, value) => {
@@ -82,49 +84,70 @@ const cachedSetProperty = (obj, property, value) => {
 	return /** @type {T} */ (result);
 };
 
-/** @typedef {Map<string, any>} ByValues */
+/**
+ * @typedef {Map<string, EXPECTED_ANY>} ByValues
+ */
 
 /**
+ * @template T
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {any | undefined} base base value
- * @property {string | undefined} byProperty the name of the selector property
- * @property {ByValues} byValues value depending on selector property, merged with base
+ * @property {T[keyof T] | undefined} base base value
+ * @property {`by${string}` | undefined} byProperty the name of the selector property
+ * @property {ByValues | undefined} byValues value depending on selector property, merged with base
+ */
+
+/** @typedef {(function(...EXPECTED_ANY): object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
+
+/**
+ * @template {object} T
+ * @typedef {Map<keyof T, ObjectParsedPropertyEntry<T>>} ParsedObjectStatic
+ */
+
+/**
+ * @template {object} T
+ * @typedef {{ byProperty: `by${string}`, fn: DynamicFunction }} ParsedObjectDynamic
  */
 
 /**
+ * @template {object} T
  * @typedef {object} ParsedObject
- * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
- * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
+ * @property {ParsedObjectStatic<T>} static static properties (key is property name)
+ * @property {ParsedObjectDynamic<T> | undefined} dynamic dynamic part
  */
 
-/** @type {WeakMap<object, ParsedObject>} */
+/** @type {WeakMap<EXPECTED_OBJECT, ParsedObject<EXPECTED_ANY>>} */
 const parseCache = new WeakMap();
 
 /**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
+ * @template {object} T
+ * @param {T} obj the object
+ * @returns {ParsedObject<T>} parsed object
  */
-const cachedParseObject = obj => {
-	const entry = parseCache.get(obj);
+const cachedParseObject = (obj) => {
+	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
 	if (entry !== undefined) return entry;
 	const result = parseObject(obj);
-	parseCache.set(obj, result);
+	parseCache.set(/** @type {EXPECTED_OBJECT} */ (obj), result);
 	return result;
 };
 
+/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+
 /**
  * @template {object} T
  * @param {T} obj the object
- * @returns {ParsedObject} parsed object
+ * @returns {ParsedObject<T>} parsed object
  */
-const parseObject = obj => {
+const parseObject = (obj) => {
+	/** @type {ParsedObjectStatic<T>} */
 	const info = new Map();
+	/** @type {ParsedObjectDynamic<T> | undefined} */
 	let dynamicInfo;
 	/**
-	 * @param {string} p path
-	 * @returns {Partial<ObjectParsedPropertyEntry>} object parsed property entry
+	 * @param {keyof T} p path
+	 * @returns {Partial<ObjectParsedPropertyEntry<T>>} object parsed property entry
 	 */
-	const getInfo = p => {
+	const getInfo = (p) => {
 		const entry = info.get(p);
 		if (entry !== undefined) return entry;
 		const newEntry = {
@@ -135,17 +158,18 @@ const parseObject = obj => {
 		info.set(p, newEntry);
 		return newEntry;
 	};
-	for (const key of Object.keys(obj)) {
-		if (key.startsWith("by")) {
-			const byProperty = /** @type {keyof T} */ (key);
-			const byObj = /** @type {object} */ (obj[byProperty]);
+	for (const key_ of Object.keys(obj)) {
+		const key = /** @type {keyof T} */ (key_);
+		if (typeof key === "string" && key.startsWith("by")) {
+			const byProperty = key;
+			const byObj = /** @type {ByObject} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
 					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
 					for (const key of Object.keys(obj)) {
-						const entry = getInfo(key);
+						const entry = getInfo(/** @type {keyof T} */ (key));
 						if (entry.byProperty === undefined) {
-							entry.byProperty = /** @type {string} */ (byProperty);
+							entry.byProperty = /** @type {`by${string}`} */ (byProperty);
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
@@ -153,17 +177,18 @@ const parseObject = obj => {
 							);
 						}
 						/** @type {ByValues} */
-						(entry.byValues).set(
-							byValue,
-							obj[/** @type {keyof (keyof T)} */ (key)]
-						);
+						(entry.byValues).set(byValue, obj[key]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
-									!(/** @type {ByValues} */ (entry.byValues).has(otherByValue))
-								)
+									!(
+										/** @type {ByValues} */
+										(entry.byValues).has(otherByValue)
+									)
+								) {
 									/** @type {ByValues} */
 									(entry.byValues).set(otherByValue, undefined);
+								}
 							}
 						}
 					}
@@ -171,7 +196,7 @@ const parseObject = obj => {
 			} else if (typeof byObj === "function") {
 				if (dynamicInfo === undefined) {
 					dynamicInfo = {
-						byProperty: key,
+						byProperty: /** @type {`by${string}`} */ (key),
 						fn: byObj
 					};
 				} else {
@@ -181,11 +206,11 @@ const parseObject = obj => {
 				}
 			} else {
 				const entry = getInfo(key);
-				entry.base = obj[/** @type {keyof T} */ (key)];
+				entry.base = obj[key];
 			}
 		} else {
 			const entry = getInfo(key);
-			entry.base = obj[/** @type {keyof T} */ (key)];
+			entry.base = obj[key];
 		}
 	}
 	return {
@@ -196,30 +221,36 @@ const parseObject = obj => {
 
 /**
  * @template {object} T
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
+ * @param {ParsedObjectStatic<T>} info static properties (key is property name)
+ * @param {{ byProperty: `by${string}`, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
-	const obj = /** @type {T} */ ({});
+	const obj = /** @type {EXPECTED_ANY} */ ({});
 	// Setup byProperty structure
 	for (const entry of info.values()) {
 		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
-			for (const byValue of entry.byValues.keys()) {
+			const byProperty = entry.byProperty;
+			const byObj = (obj[byProperty] = obj[byProperty] || {});
+			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
 	}
 	for (const [key, entry] of info) {
 		if (entry.base !== undefined) {
-			obj[/** @type {keyof T} */ (key)] = entry.base;
+			obj[key] = entry.base;
 		}
 		// Fill byProperty structure
 		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+			const byProperty = entry.byProperty;
+			const byObj = (obj[byProperty] = obj[byProperty] || {});
 			for (const byValue of Object.keys(byObj)) {
-				const value = getFromByValues(entry.byValues, byValue);
+				const value = getFromByValues(
+					/** @type {ByValues} */
+					(entry.byValues),
+					byValue
+				);
 				if (value !== undefined) byObj[byValue][key] = value;
 			}
 		}
@@ -237,10 +268,11 @@ const VALUE_TYPE_OBJECT = 3;
 const VALUE_TYPE_DELETE = 4;
 
 /**
- * @param {any} value a single value
+ * @template T
+ * @param {T} value a single value
  * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
  */
-const getValueType = value => {
+const getValueType = (value) => {
 	if (value === undefined) {
 		return VALUE_TYPE_UNDEFINED;
 	} else if (value === DELETE) {
@@ -278,11 +310,13 @@ const cleverMerge = (first, second) => {
 };
 
 /**
+ * @template {object} T
+ * @template {object} O
  * Merges two objects. Objects are deeply clever merged.
- * @param {object} first first object
- * @param {object} second second object
+ * @param {T} first first
+ * @param {O} second second
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {object} merged object of first and second object
+ * @returns {T & O} merged object of first and second object
  */
 const _cleverMerge = (first, second, internalCaching = false) => {
 	const firstObject = internalCaching
@@ -295,11 +329,16 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		let { byProperty, fn } = firstDynamicInfo;
 		const fnInfo = fn[DYNAMIC_INFO];
 		if (fnInfo) {
-			second = internalCaching
-				? cachedCleverMerge(fnInfo[1], second)
-				: cleverMerge(fnInfo[1], second);
+			second =
+				/** @type {O} */
+				(
+					internalCaching
+						? cachedCleverMerge(fnInfo[1], second)
+						: cleverMerge(fnInfo[1], second)
+				);
 			fn = fnInfo[0];
 		}
+		/** @type {DynamicFunction} */
 		const newFn = (...args) => {
 			const fnResult = fn(...args);
 			return internalCaching
@@ -307,7 +346,9 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 				: cleverMerge(fnResult, second);
 		};
 		newFn[DYNAMIC_INFO] = [fn, second];
-		return serializeObject(firstObject.static, { byProperty, fn: newFn });
+		return /** @type {T & O} */ (
+			serializeObject(firstObject.static, { byProperty, fn: newFn })
+		);
 	}
 
 	// If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
@@ -315,10 +356,12 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		? cachedParseObject(second)
 		: parseObject(second);
 	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
-	/** @type {Map<string, ObjectParsedPropertyEntry>} */
 	const resultInfo = new Map();
 	for (const [key, firstEntry] of firstInfo) {
-		const secondEntry = secondInfo.get(key);
+		const secondEntry = secondInfo.get(
+			/** @type {keyof (T | O)} */
+			(key)
+		);
 		const entry =
 			secondEntry !== undefined
 				? mergeEntries(firstEntry, secondEntry, internalCaching)
@@ -326,18 +369,19 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		resultInfo.set(key, entry);
 	}
 	for (const [key, secondEntry] of secondInfo) {
-		if (!firstInfo.has(key)) {
+		if (!firstInfo.has(/** @type {keyof (T | O)} */ (key))) {
 			resultInfo.set(key, secondEntry);
 		}
 	}
-	return serializeObject(resultInfo, secondDynamicInfo);
+	return /** @type {T & O} */ (serializeObject(resultInfo, secondDynamicInfo));
 };
 
 /**
- * @param {ObjectParsedPropertyEntry} firstEntry a
- * @param {ObjectParsedPropertyEntry} secondEntry b
+ * @template T, O
+ * @param {ObjectParsedPropertyEntry<T>} firstEntry a
+ * @param {ObjectParsedPropertyEntry<O>} secondEntry b
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry} new entry
+ * @returns {ObjectParsedPropertyEntry<T> | ObjectParsedPropertyEntry<O> | ObjectParsedPropertyEntry<T & O>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -363,8 +407,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				// = first.base + (first.byProperty + second.byProperty)
 				// need to merge first and second byValues
 				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of secondEntry.byValues) {
-					const firstValue = getFromByValues(firstEntry.byValues, key);
+				for (const [key, value] of /** @type {ByValues} */ (
+					secondEntry.byValues
+				)) {
+					const firstValue = getFromByValues(
+						/** @type {ByValues} */
+						(firstEntry.byValues),
+						key
+					);
 					newByValues.set(
 						key,
 						mergeSingleValue(firstValue, value, internalCaching)
@@ -381,11 +431,15 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				// The simple case
 				// = (first.base + second.base) + second.byProperty
 				return {
-					base: mergeSingleValue(
-						firstEntry.base,
-						secondEntry.base,
-						internalCaching
-					),
+					base:
+						/** @type {T[keyof T] & O[keyof O]} */
+						(
+							mergeSingleValue(
+								firstEntry.base,
+								secondEntry.base,
+								internalCaching
+							)
+						),
 					byProperty: secondEntry.byProperty,
 					byValues: secondEntry.byValues
 				};
@@ -399,10 +453,12 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				Array.from(firstEntry.byValues.values()).every(value => {
-					const type = getValueType(value);
-					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-				})
+				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
+					(value) => {
+						const type = getValueType(value);
+						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+					}
+				)
 			) {
 				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
 				newBase = mergeSingleValue(
@@ -413,13 +469,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			} else {
 				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
 				newBase = firstEntry.base;
-				if (!intermediateByValues.has("default"))
+				if (!intermediateByValues.has("default")) {
 					intermediateByValues.set("default", secondEntry.base);
+				}
 			}
 			if (!secondEntry.byProperty) {
 				// = first.base + (first.byProperty + second.base)
 				return {
-					base: newBase,
+					base: /** @type {T[keyof T] & O[keyof O]} */ (newBase),
 					byProperty: firstEntry.byProperty,
 					byValues: intermediateByValues
 				};
@@ -429,7 +486,9 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of secondEntry.byValues) {
+			for (const [key, value] of /** @type {ByValues} */ (
+				secondEntry.byValues
+			)) {
 				const firstValue = getFromByValues(intermediateByValues, key);
 				newByValues.set(
 					key,
@@ -437,7 +496,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			return {
-				base: newBase,
+				base: /** @type {T[keyof T] & O[keyof O]} */ (newBase),
 				byProperty: firstEntry.byProperty,
 				byValues: newByValues
 			};
@@ -446,9 +505,10 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 };
 
 /**
- * @param {Map<string, any>} byValues all values
+ * @template V
+ * @param {ByValues} byValues all values
  * @param {string} key value of the selector
- * @returns {any | undefined} value
+ * @returns {V | undefined} value
  */
 const getFromByValues = (byValues, key) => {
 	if (key !== "default" && byValues.has(key)) {
@@ -458,10 +518,12 @@ const getFromByValues = (byValues, key) => {
 };
 
 /**
- * @param {any} a value
- * @param {any} b value
+ * @template A
+ * @template B
+ * @param {A | A[]} a value
+ * @param {B | B[]} b value
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {any} value
+ * @returns {A & B | (A | B)[] | A | A[] | B | B[]} value
  */
 const mergeSingleValue = (a, b, internalCaching) => {
 	const bType = getValueType(b);
@@ -490,12 +552,13 @@ const mergeSingleValue = (a, b, internalCaching) => {
 				case VALUE_TYPE_UNDEFINED:
 					return b;
 				case VALUE_TYPE_DELETE:
-					return /** @type {any[]} */ (b).filter(item => item !== "...");
+					return /** @type {B[]} */ (b).filter((item) => item !== "...");
 				case VALUE_TYPE_ARRAY_EXTEND: {
+					/** @type {(A | B)[]} */
 					const newArray = [];
-					for (const item of b) {
+					for (const item of /** @type {B[]} */ (b)) {
 						if (item === "...") {
-							for (const item of a) {
+							for (const item of /** @type {A[]} */ (a)) {
 								newArray.push(item);
 							}
 						} else {
@@ -505,8 +568,8 @@ const mergeSingleValue = (a, b, internalCaching) => {
 					return newArray;
 				}
 				case VALUE_TYPE_OBJECT:
-					return /** @type {any[]} */ (b).map(item =>
-						item === "..." ? a : item
+					return /** @type {(A | B)[]} */ (b).map((item) =>
+						item === "..." ? /** @type {A} */ (a) : item
 					);
 				default:
 					throw new Error("Not implemented");
@@ -524,14 +587,12 @@ const mergeSingleValue = (a, b, internalCaching) => {
  */
 const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 	const newObj = /** @type {T} */ ({});
-	for (const key of Object.keys(obj)) {
-		const value = obj[/** @type {keyof T} */ (key)];
+	for (const _key of Object.keys(obj)) {
+		const key = /** @type {keyof T} */ (_key);
+		const value = obj[key];
 		const type = getValueType(value);
-		if (
-			type === VALUE_TYPE_OBJECT &&
-			keysToKeepOriginalValue.includes(/** @type {keyof T} */ (key))
-		) {
-			newObj[/** @type {keyof T} */ (key)] = value;
+		if (type === VALUE_TYPE_OBJECT && keysToKeepOriginalValue.includes(key)) {
+			newObj[key] = value;
 			continue;
 		}
 		switch (type) {
@@ -539,25 +600,26 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 			case VALUE_TYPE_DELETE:
 				break;
 			case VALUE_TYPE_OBJECT:
-				newObj[/** @type {keyof T} */ (key)] =
+				newObj[key] =
 					/** @type {T[keyof T]} */
 					(
 						removeOperations(
-							/** @type {TODO} */ (value),
+							/** @type {T} */
+							(value),
 							keysToKeepOriginalValue
 						)
 					);
 				break;
 			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[/** @type {keyof T} */ (key)] =
+				newObj[key] =
 					/** @type {T[keyof T]} */
 					(
-						/** @type {any[]} */
-						(value).filter(i => i !== "...")
+						/** @type {EXPECTED_ANY[]} */
+						(value).filter((i) => i !== "...")
 					);
 				break;
 			default:
-				newObj[/** @type {keyof T} */ (key)] = value;
+				newObj[key] = value;
 				break;
 		}
 	}
@@ -566,10 +628,11 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 
 /**
  * @template T
- * @template {string} P
+ * @template {keyof T} P
+ * @template V
  * @param {T} obj the object
  * @param {P} byProperty the by description
- * @param  {...any} values values
+ * @param {...V} values values
  * @returns {Omit<T, P>} object with merged byProperty
  */
 const resolveByProperty = (obj, byProperty, ...values) => {
@@ -579,10 +642,10 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	const { [byProperty]: _byValue, ..._remaining } = obj;
 	const remaining = /** @type {T} */ (_remaining);
 	const byValue =
-		/** @type {Record<string, T> | function(...any[]): T} */
+		/** @type {Record<string, T> | ((...args: V[]) => T)} */
 		(_byValue);
 	if (typeof byValue === "object") {
-		const key = values[0];
+		const key = /** @type {string} */ (values[0]);
 		if (key in byValue) {
 			return cachedCleverMerge(remaining, byValue[key]);
 		} else if ("default" in byValue) {
@@ -597,11 +660,12 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 			resolveByProperty(result, byProperty, ...values)
 		);
 	}
+	return obj;
 };
 
-module.exports.cachedSetProperty = cachedSetProperty;
+module.exports.DELETE = DELETE;
 module.exports.cachedCleverMerge = cachedCleverMerge;
+module.exports.cachedSetProperty = cachedSetProperty;
 module.exports.cleverMerge = cleverMerge;
-module.exports.resolveByProperty = resolveByProperty;
 module.exports.removeOperations = removeOperations;
-module.exports.DELETE = DELETE;
+module.exports.resolveByProperty = resolveByProperty;