webpack 5.59.0 → 5.94.0

package/lib/util/runtime.js

@@ -19,7 +19,7 @@ const SortableSet = require("./SortableSet");
  * @param {EntryOptions=} options optionally already received entry options
  * @returns {RuntimeSpec} runtime
  */
-exports.getEntryRuntime = (compilation, name, options) => {
+module.exports.getEntryRuntime = (compilation, name, options) => {
 	let dependOn;
 	let runtime;
 	if (options) {
@@ -31,7 +31,7 @@ exports.getEntryRuntime = (compilation, name, options) => {
 	}
 	if (dependOn) {
 		/** @type {RuntimeSpec} */
-		let result = undefined;
+		let result;
 		const queue = new Set(dependOn);
 		for (const name of queue) {
 			const dep = compilation.entries.get(name);
@@ -46,18 +46,17 @@ exports.getEntryRuntime = (compilation, name, options) => {
 			}
 		}
 		return result || name;
-	} else {
-		return runtime || name;
 	}
+	return runtime || name;
 };
 
 /**
  * @param {RuntimeSpec} runtime runtime
- * @param {function(string): void} fn functor
+ * @param {function(string | undefined): void} fn functor
  * @param {boolean} deterministicOrder enforce a deterministic order
  * @returns {void}
  */
-exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
+const forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 	if (runtime === undefined) {
 		fn(undefined);
 	} else if (typeof runtime === "string") {
@@ -69,7 +68,13 @@ exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 		}
 	}
 };
+module.exports.forEachRuntime = forEachRuntime;
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime key
+ */
 const getRuntimesKey = set => {
 	set.sort();
 	return Array.from(set).join("\n");
@@ -84,20 +89,25 @@ const getRuntimeKey = runtime => {
 	if (typeof runtime === "string") return runtime;
 	return runtime.getFromUnorderedCache(getRuntimesKey);
 };
-exports.getRuntimeKey = getRuntimeKey;
+module.exports.getRuntimeKey = getRuntimeKey;
 
 /**
  * @param {string} key key of runtimes
  * @returns {RuntimeSpec} runtime(s)
  */
 const keyToRuntime = key => {
-	if (key === "*") return undefined;
+	if (key === "*") return;
 	const items = key.split("\n");
 	if (items.length === 1) return items[0];
 	return new SortableSet(items);
 };
-exports.keyToRuntime = keyToRuntime;
+module.exports.keyToRuntime = keyToRuntime;
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime string
+ */
 const getRuntimesString = set => {
 	set.sort();
 	return Array.from(set).join("+");
@@ -112,13 +122,13 @@ const runtimeToString = runtime => {
 	if (typeof runtime === "string") return runtime;
 	return runtime.getFromUnorderedCache(getRuntimesString);
 };
-exports.runtimeToString = runtimeToString;
+module.exports.runtimeToString = runtimeToString;
 
 /**
  * @param {RuntimeCondition} runtimeCondition runtime condition
  * @returns {string} readable version
  */
-exports.runtimeConditionToString = runtimeCondition => {
+module.exports.runtimeConditionToString = runtimeCondition => {
 	if (runtimeCondition === true) return "true";
 	if (runtimeCondition === false) return "false";
 	return runtimeToString(runtimeCondition);
@@ -141,40 +151,38 @@ const runtimeEqual = (a, b) => {
 		return false;
 	} else if (a.size !== b.size) {
 		return false;
-	} else {
-		a.sort();
-		b.sort();
-		const aIt = a[Symbol.iterator]();
-		const bIt = b[Symbol.iterator]();
-		for (;;) {
-			const aV = aIt.next();
-			if (aV.done) return true;
-			const bV = bIt.next();
-			if (aV.value !== bV.value) return false;
-		}
+	}
+	a.sort();
+	b.sort();
+	const aIt = a[Symbol.iterator]();
+	const bIt = b[Symbol.iterator]();
+	for (;;) {
+		const aV = aIt.next();
+		if (aV.done) return true;
+		const bV = bIt.next();
+		if (aV.value !== bV.value) return false;
 	}
 };
-exports.runtimeEqual = runtimeEqual;
+module.exports.runtimeEqual = runtimeEqual;
 
 /**
  * @param {RuntimeSpec} a first
  * @param {RuntimeSpec} b second
  * @returns {-1|0|1} compare
  */
-exports.compareRuntime = (a, b) => {
+module.exports.compareRuntime = (a, b) => {
 	if (a === b) {
 		return 0;
 	} else if (a === undefined) {
 		return -1;
 	} else if (b === undefined) {
 		return 1;
-	} else {
-		const aKey = getRuntimeKey(a);
-		const bKey = getRuntimeKey(b);
-		if (aKey < bKey) return -1;
-		if (aKey > bKey) return 1;
-		return 0;
 	}
+	const aKey = getRuntimeKey(a);
+	const bKey = getRuntimeKey(b);
+	if (aKey < bKey) return -1;
+	if (aKey > bKey) return 1;
+	return 0;
 };
 
 /**
@@ -197,26 +205,23 @@ const mergeRuntime = (a, b) => {
 			return set;
 		} else if (b.has(a)) {
 			return b;
-		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return a;
-			const set = new SortableSet(a);
-			set.add(b);
-			return set;
-		} else {
-			const set = new SortableSet(a);
-			for (const item of b) set.add(item);
-			if (set.size === a.size) return a;
-			return set;
 		}
+		const set = new SortableSet(b);
+		set.add(a);
+		return set;
+	}
+	if (typeof b === "string") {
+		if (a.has(b)) return a;
+		const set = new SortableSet(a);
+		set.add(b);
+		return set;
 	}
+	const set = new SortableSet(a);
+	for (const item of b) set.add(item);
+	if (set.size === a.size) return a;
+	return set;
 };
-exports.mergeRuntime = mergeRuntime;
+module.exports.mergeRuntime = mergeRuntime;
 
 /**
  * @param {RuntimeCondition} a first
@@ -224,12 +229,12 @@ exports.mergeRuntime = mergeRuntime;
  * @param {RuntimeSpec} runtime full runtime
  * @returns {RuntimeCondition} result
  */
-exports.mergeRuntimeCondition = (a, b, runtime) => {
+module.exports.mergeRuntimeCondition = (a, b, runtime) => {
 	if (a === false) return b;
 	if (b === false) return a;
 	if (a === true || b === true) return true;
 	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
+	if (merged === undefined) return;
 	if (typeof merged === "string") {
 		if (typeof runtime === "string" && merged === runtime) return true;
 		return merged;
@@ -245,10 +250,10 @@ exports.mergeRuntimeCondition = (a, b, runtime) => {
  * @param {RuntimeSpec} runtime full runtime
  * @returns {RuntimeSpec | true} result
  */
-exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
+module.exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
 	if (a === true || b === true) return true;
 	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
+	if (merged === undefined) return;
 	if (typeof merged === "string") {
 		if (typeof runtime === "string" && merged === runtime) return true;
 		return merged;
@@ -271,38 +276,34 @@ const mergeRuntimeOwned = (a, b) => {
 	} else if (a === undefined) {
 		if (typeof b === "string") {
 			return b;
-		} else {
-			return new SortableSet(b);
 		}
+		return new SortableSet(b);
 	} else if (typeof a === "string") {
 		if (typeof b === "string") {
 			const set = new SortableSet();
 			set.add(a);
 			set.add(b);
 			return set;
-		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
-		}
-	} else {
-		if (typeof b === "string") {
-			a.add(b);
-			return a;
-		} else {
-			for (const item of b) a.add(item);
-			return a;
 		}
+		const set = new SortableSet(b);
+		set.add(a);
+		return set;
+	}
+	if (typeof b === "string") {
+		a.add(b);
+		return a;
 	}
+	for (const item of b) a.add(item);
+	return a;
 };
-exports.mergeRuntimeOwned = mergeRuntimeOwned;
+module.exports.mergeRuntimeOwned = mergeRuntimeOwned;
 
 /**
  * @param {RuntimeSpec} a first
  * @param {RuntimeSpec} b second
  * @returns {RuntimeSpec} merged
  */
-exports.intersectRuntime = (a, b) => {
+module.exports.intersectRuntime = (a, b) => {
 	if (a === undefined) {
 		return b;
 	} else if (b === undefined) {
@@ -311,26 +312,26 @@ exports.intersectRuntime = (a, b) => {
 		return a;
 	} else if (typeof a === "string") {
 		if (typeof b === "string") {
-			return undefined;
+			return;
 		} else if (b.has(a)) {
 			return a;
-		} else {
-			return undefined;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return b;
-			return undefined;
-		} else {
-			const set = new SortableSet();
-			for (const item of b) {
-				if (a.has(item)) set.add(item);
-			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
 		}
+		return;
+	}
+	if (typeof b === "string") {
+		if (a.has(b)) return b;
+		return;
+	}
+	const set = new SortableSet();
+	for (const item of b) {
+		if (a.has(item)) set.add(item);
 	}
+	if (set.size === 0) return;
+	if (set.size === 1) {
+		const [item] = set;
+		return item;
+	}
+	return set;
 };
 
 /**
@@ -340,41 +341,42 @@ exports.intersectRuntime = (a, b) => {
  */
 const subtractRuntime = (a, b) => {
 	if (a === undefined) {
-		return undefined;
+		return;
 	} else if (b === undefined) {
 		return a;
 	} else if (a === b) {
-		return undefined;
+		return;
 	} else if (typeof a === "string") {
 		if (typeof b === "string") {
 			return a;
 		} else if (b.has(a)) {
-			return undefined;
-		} else {
-			return a;
+			return;
 		}
-	} else {
-		if (typeof b === "string") {
-			if (!a.has(b)) return a;
-			if (a.size === 2) {
-				for (const item of a) {
-					if (item !== b) return item;
-				}
-			}
-			const set = new SortableSet(a);
-			set.delete(b);
-		} else {
-			const set = new SortableSet();
+		return a;
+	}
+	if (typeof b === "string") {
+		if (!a.has(b)) return a;
+		if (a.size === 2) {
 			for (const item of a) {
-				if (!b.has(item)) set.add(item);
+				if (item !== b) return item;
 			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
 		}
+		const set = new SortableSet(a);
+		set.delete(b);
+		return set;
+	}
+	const set = new SortableSet();
+	for (const item of a) {
+		if (!b.has(item)) set.add(item);
 	}
+	if (set.size === 0) return;
+	if (set.size === 1) {
+		const [item] = set;
+		return item;
+	}
+	return set;
 };
-exports.subtractRuntime = subtractRuntime;
+module.exports.subtractRuntime = subtractRuntime;
 
 /**
  * @param {RuntimeCondition} a first
@@ -382,7 +384,7 @@ exports.subtractRuntime = subtractRuntime;
  * @param {RuntimeSpec} runtime runtime
  * @returns {RuntimeCondition} result
  */
-exports.subtractRuntimeCondition = (a, b, runtime) => {
+module.exports.subtractRuntimeCondition = (a, b, runtime) => {
 	if (b === true) return false;
 	if (b === false) return a;
 	if (a === false) return false;
@@ -392,15 +394,15 @@ exports.subtractRuntimeCondition = (a, b, runtime) => {
 
 /**
  * @param {RuntimeSpec} runtime runtime
- * @param {function(RuntimeSpec): boolean} filter filter function
+ * @param {function(RuntimeSpec=): boolean} filter filter function
  * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
  */
-exports.filterRuntime = (runtime, filter) => {
-	if (runtime === undefined) return filter(undefined);
+module.exports.filterRuntime = (runtime, filter) => {
+	if (runtime === undefined) return filter();
 	if (typeof runtime === "string") return filter(runtime);
 	let some = false;
 	let every = true;
-	let result = undefined;
+	let result;
 	for (const r of runtime) {
 		const v = filter(r);
 		if (v) {
@@ -415,6 +417,11 @@ exports.filterRuntime = (runtime, filter) => {
 	return result;
 };
 
+/**
+ * @template T
+ * @typedef {Map<string, T>} RuntimeSpecMapInnerMap
+ */
+
 /**
  * @template T
  */
@@ -426,26 +433,28 @@ class RuntimeSpecMap {
 		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
 		/** @type {RuntimeSpec} */
 		this._singleRuntime = clone ? clone._singleRuntime : undefined;
-		/** @type {T} */
+		/** @type {T | undefined} */
 		this._singleValue = clone ? clone._singleValue : undefined;
-		/** @type {Map<string, T> | undefined} */
+		/** @type {RuntimeSpecMapInnerMap<T> | undefined} */
 		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
+	 * @returns {T | undefined} value
 	 */
 	get(runtime) {
 		switch (this._mode) {
 			case 0:
-				return undefined;
+				return;
 			case 1:
 				return runtimeEqual(this._singleRuntime, runtime)
 					? this._singleValue
 					: undefined;
 			default:
-				return this._map.get(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).get(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
@@ -460,10 +469,16 @@ class RuntimeSpecMap {
 			case 1:
 				return runtimeEqual(this._singleRuntime, runtime);
 			default:
-				return this._map.has(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).has(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {T} value the value
+	 */
 	set(runtime, value) {
 		switch (this._mode) {
 			case 0:
@@ -478,15 +493,24 @@ class RuntimeSpecMap {
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 			/* falls through */
 			default:
-				this._map.set(getRuntimeKey(runtime), value);
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).set(getRuntimeKey(runtime), value);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {() => TODO} computer function to compute the value
+	 * @returns {TODO} true, when the runtime was deleted
+	 */
 	provide(runtime, computer) {
 		switch (this._mode) {
 			case 0:
@@ -495,11 +519,14 @@ class RuntimeSpecMap {
 				return (this._singleValue = computer());
 			case 1: {
 				if (runtimeEqual(this._singleRuntime, runtime)) {
-					return this._singleValue;
+					return /** @type {T} */ (this._singleValue);
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 				const newValue = computer();
@@ -508,15 +535,19 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const value = this._map.get(key);
+				const value = /** @type {Map<string, T>} */ (this._map).get(key);
 				if (value !== undefined) return value;
 				const newValue = computer();
-				this._map.set(key, newValue);
+				/** @type {Map<string, T>} */
+				(this._map).set(key, newValue);
 				return newValue;
 			}
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 */
 	delete(runtime) {
 		switch (this._mode) {
 			case 0:
@@ -529,10 +560,15 @@ class RuntimeSpecMap {
 				}
 				return;
 			default:
-				this._map.delete(getRuntimeKey(runtime));
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).delete(getRuntimeKey(runtime));
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {function(T | undefined): T} fn function to update the value
+	 */
 	update(runtime, fn) {
 		switch (this._mode) {
 			case 0:
@@ -546,7 +582,10 @@ class RuntimeSpecMap {
 				if (newValue !== undefined) {
 					this._mode = 2;
 					this._map = new Map();
-					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._map.set(
+						getRuntimeKey(this._singleRuntime),
+						/** @type {T} */ (this._singleValue)
+					);
 					this._singleRuntime = undefined;
 					this._singleValue = undefined;
 					this._map.set(getRuntimeKey(runtime), newValue);
@@ -555,9 +594,11 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const oldValue = this._map.get(key);
+				const oldValue = /** @type {Map<string, T>} */ (this._map).get(key);
 				const newValue = fn(oldValue);
-				if (newValue !== oldValue) this._map.set(key, newValue);
+				if (newValue !== oldValue)
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).set(key, newValue);
 			}
 		}
 	}
@@ -569,7 +610,11 @@ class RuntimeSpecMap {
 			case 1:
 				return [this._singleRuntime];
 			default:
-				return Array.from(this._map.keys(), keyToRuntime);
+				return Array.from(
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).keys(),
+					keyToRuntime
+				);
 		}
 	}
 
@@ -578,21 +623,24 @@ class RuntimeSpecMap {
 			case 0:
 				return [][Symbol.iterator]();
 			case 1:
-				return [this._singleValue][Symbol.iterator]();
+				return [/** @type {T} */ (this._singleValue)][Symbol.iterator]();
 			default:
-				return this._map.values();
+				return /** @type {Map<string, T>} */ (this._map).values();
 		}
 	}
 
 	get size() {
-		if (this._mode <= 1) return this._mode;
-		return this._map.size;
+		if (/** @type {number} */ (this._mode) <= 1) return this._mode;
+		return /** @type {Map<string, T>} */ (this._map).size;
 	}
 }
 
-exports.RuntimeSpecMap = RuntimeSpecMap;
+module.exports.RuntimeSpecMap = RuntimeSpecMap;
 
 class RuntimeSpecSet {
+	/**
+	 * @param {Iterable<RuntimeSpec>=} iterable iterable
+	 */
 	constructor(iterable) {
 		/** @type {Map<string, RuntimeSpec>} */
 		this._map = new Map();
@@ -603,10 +651,17 @@ class RuntimeSpecSet {
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 */
 	add(runtime) {
 		this._map.set(getRuntimeKey(runtime), runtime);
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {boolean} true, when the runtime exists
+	 */
 	has(runtime) {
 		return this._map.has(getRuntimeKey(runtime));
 	}
@@ -620,4 +675,4 @@ class RuntimeSpecSet {
 	}
 }
 
-exports.RuntimeSpecSet = RuntimeSpecSet;
+module.exports.RuntimeSpecSet = RuntimeSpecSet;