webpack 5.99.9 → 5.100.1

package/lib/util/cleverMerge.js

@@ -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) {
@@ -83,32 +85,43 @@ const cachedSetProperty = (obj, property, value) => {
 };
 
 /**
- * @template V
- * @typedef {Map<string, V | undefined>} ByValues
+ * @typedef {Map<string, EXPECTED_ANY>} ByValues
  */
 
 /**
+ * @template T
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {TODO | undefined} base base value
+ * @property {T[keyof T] | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
- * @property {ByValues<TODO>} byValues value depending on selector property, merged with base
+ * @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: 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: DynamicFunction } | undefined} dynamic dynamic part
+ * @property {ParsedObjectStatic<T>} static static properties (key is property name)
+ * @property {ParsedObjectDynamic<T> | undefined} dynamic dynamic part
  */
 
-/** @type {WeakMap<EXPECTED_OBJECT, ParsedObject>} */
+/** @type {WeakMap<EXPECTED_OBJECT, ParsedObject<EXPECTED_ANY>>} */
 const parseCache = new WeakMap();
 
 /**
  * @template {object} T
  * @param {T} obj the object
- * @returns {ParsedObject} parsed object
+ * @returns {ParsedObject<T>} parsed object
  */
 const cachedParseObject = obj => {
 	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
@@ -118,18 +131,21 @@ const cachedParseObject = obj => {
 	return result;
 };
 
+/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+
 /**
  * @template {object} T
- * @template V
  * @param {T} obj the object
- * @returns {ParsedObject} parsed object
+ * @returns {ParsedObject<T>} parsed object
  */
 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 entry = info.get(p);
@@ -142,38 +158,37 @@ 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 {TODO} */ (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 = byProperty;
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
 								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						/** @type {ByValues<V>} */
-						(entry.byValues).set(
-							byValue,
-							obj[/** @type {keyof (keyof T)} */ (key)]
-						);
+						/** @type {ByValues} */
+						(entry.byValues).set(byValue, obj[key]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
 									!(
-										/** @type {ByValues<V>} */
+										/** @type {ByValues} */
 										(entry.byValues).has(otherByValue)
 									)
-								)
-									/** @type {ByValues<V>} */
+								) {
+									/** @type {ByValues} */
 									(entry.byValues).set(otherByValue, undefined);
+								}
 							}
 						}
 					}
@@ -191,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 {
@@ -206,8 +221,8 @@ const parseObject = obj => {
 
 /**
  * @template {object} T
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: (...args: EXPECTED_ANY[]) => T } | undefined} dynamicInfo dynamic part
+ * @param {ParsedObjectStatic<T>} info static properties (key is property name)
+ * @param {{ byProperty: string, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
@@ -218,7 +233,7 @@ const serializeObject = (info, dynamicInfo) => {
 			const byProperty = /** @type {keyof T} */ (entry.byProperty);
 			const byObj = (obj[byProperty] =
 				obj[byProperty] || /** @type {TODO} */ ({}));
-			for (const byValue of entry.byValues.keys()) {
+			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
@@ -233,7 +248,11 @@ const serializeObject = (info, dynamicInfo) => {
 			const byObj = (obj[byProperty] =
 				obj[byProperty] || /** @type {TODO} */ ({}));
 			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;
 			}
 		}
@@ -314,7 +333,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		const fnInfo = fn[DYNAMIC_INFO];
 		if (fnInfo) {
 			second =
-				/** @type {TODO} */
+				/** @type {O} */
 				(
 					internalCaching
 						? cachedCleverMerge(fnInfo[1], second)
@@ -340,10 +359,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)
@@ -351,7 +372,7 @@ 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);
 		}
 	}
@@ -359,10 +380,11 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 };
 
 /**
- * @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<TODO>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -388,8 +410,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)
@@ -406,11 +434,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
 				};
@@ -424,10 +456,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(
@@ -438,8 +472,9 @@ 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)
@@ -454,7 +489,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,
@@ -472,7 +509,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 
 /**
  * @template V
- * @param {ByValues<V>} byValues all values
+ * @param {ByValues} byValues all values
  * @param {string} key value of the selector
  * @returns {V | undefined} value
  */
@@ -629,9 +666,9 @@ const resolveByProperty = (obj, 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;