webpack 5.93.0 → 5.95.0

package/lib/util/AsyncQueue.js

@@ -20,7 +20,7 @@ let inHandleResult = 0;
  * @template T
  * @callback Callback
  * @param {(WebpackError | null)=} err
- * @param {T=} result
+ * @param {(T | null)=} result
  */
 
 /**
@@ -37,15 +37,27 @@ class AsyncQueueEntry {
 		this.item = item;
 		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
 		this.state = QUEUED_STATE;
+		/** @type {Callback<R> | undefined} */
 		this.callback = callback;
 		/** @type {Callback<R>[] | undefined} */
 		this.callbacks = undefined;
+		/** @type {R | null | undefined} */
 		this.result = undefined;
-		/** @type {WebpackError | undefined} */
+		/** @type {WebpackError | null | undefined} */
 		this.error = undefined;
 	}
 }
 
+/**
+ * @template T, K
+ * @typedef {function(T): K} getKey
+ */
+
+/**
+ * @template T, R
+ * @typedef {function(T, Callback<R>): void} Processor
+ */
+
 /**
  * @template T
  * @template K
@@ -57,15 +69,16 @@ class AsyncQueue {
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
 	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
-	 * @param {function(T): K=} options.getKey extract key from item
-	 * @param {function(T, Callback<R>): void} options.processor async function to process items
+	 * @param {getKey<T, K>=} options.getKey extract key from item
+	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
 	constructor({ name, parallelism, parent, processor, getKey }) {
 		this._name = name;
 		this._parallelism = parallelism || 1;
 		this._processor = processor;
 		this._getKey =
-			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
+			getKey ||
+			/** @type {getKey<T, K>} */ (item => /** @type {T & K} */ (item));
 		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
 		this._entries = new Map();
 		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
@@ -76,6 +89,7 @@ class AsyncQueue {
 		this._willEnsureProcessing = false;
 		this._needProcessing = false;
 		this._stopped = false;
+		/** @type {AsyncQueue<any, any, any>} */
 		this._root = parent ? parent._root : this;
 		if (parent) {
 			if (this._root._children === undefined) {
@@ -94,7 +108,7 @@ class AsyncQueue {
 			beforeStart: new AsyncSeriesHook(["item"]),
 			/** @type {SyncHook<[T]>} */
 			started: new SyncHook(["item"]),
-			/** @type {SyncHook<[T, Error, R]>} */
+			/** @type {SyncHook<[T, WebpackError | null | undefined, R | null | undefined]>} */
 			result: new SyncHook(["item", "error", "result"])
 		};
 
@@ -202,9 +216,14 @@ class AsyncQueue {
 		this._queued = new ArrayQueue();
 		const root = this._root;
 		for (const entry of queue) {
-			this._entries.delete(this._getKey(entry.item));
+			this._entries.delete(
+				this._getKey(/** @type {AsyncQueueEntry<T, K, R>} */ (entry).item)
+			);
 			root._activeTasks++;
-			this._handleResult(entry, new WebpackError("Queue was stopped"));
+			this._handleResult(
+				/** @type {AsyncQueueEntry<T, K, R>} */ (entry),
+				new WebpackError("Queue was stopped")
+			);
 		}
 	}
 
@@ -308,7 +327,7 @@ class AsyncQueue {
 				});
 			} catch (err) {
 				if (inCallback) throw err;
-				this._handleResult(entry, err, null);
+				this._handleResult(entry, /** @type {WebpackError} */ (err), null);
 			}
 			this.hooks.started.call(entry.item);
 		});
@@ -316,8 +335,8 @@ class AsyncQueue {
 
 	/**
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
-	 * @param {WebpackError=} err error, if any
-	 * @param {R=} result result, if any
+	 * @param {(WebpackError | null)=} err error, if any
+	 * @param {(R | null)=} result result, if any
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
@@ -326,7 +345,7 @@ class AsyncQueue {
 				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
 				: err;
 
-			const callback = entry.callback;
+			const callback = /** @type {Callback<R>} */ (entry.callback);
 			const callbacks = entry.callbacks;
 			entry.state = DONE_STATE;
 			entry.callback = undefined;

package/lib/util/IterableHelpers.js

@@ -36,11 +36,10 @@ const someInIterable = (iterable, filter) => {
  */
 const countIterable = iterable => {
 	let i = 0;
-	// eslint-disable-next-line no-unused-vars
 	for (const _ of iterable) i++;
 	return i;
 };
 
-exports.last = last;
-exports.someInIterable = someInIterable;
-exports.countIterable = countIterable;
+module.exports.last = last;
+module.exports.someInIterable = someInIterable;
+module.exports.countIterable = countIterable;

package/lib/util/LazyBucketSortedSet.js

@@ -8,6 +8,16 @@
 const { first } = require("./SetHelpers");
 const SortableSet = require("./SortableSet");
 
+/**
+ * @template T
+ * @typedef {LazyBucketSortedSet<T, any> | SortableSet<T>} Entry
+ */
+
+/**
+ * @template T
+ * @typedef {(function(T): any) | (function(any, any): number)} Arg
+ */
+
 /**
  * Multi layer bucket sorted set:
  * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
@@ -24,14 +34,15 @@ class LazyBucketSortedSet {
 	/**
 	 * @param {function(T): K} getKey function to get key from item
 	 * @param {function(K, K): number} comparator comparator to sort keys
-	 * @param  {...((function(T): any) | (function(any, any): number))} args more pairs of getKey and comparator plus optional final comparator for the last layer
+	 * @param  {...Arg<T>} args more pairs of getKey and comparator plus optional final comparator for the last layer
 	 */
 	constructor(getKey, comparator, ...args) {
 		this._getKey = getKey;
+		/** @type {Arg<T>[]} */
 		this._innerArgs = args;
 		this._leaf = args.length <= 1;
 		this._keys = new SortableSet(undefined, comparator);
-		/** @type {Map<K, LazyBucketSortedSet<T, any> | SortableSet<T>>} */
+		/** @type {Map<K, Entry<T>>} */
 		this._map = new Map();
 		this._unsortedItems = new Set();
 		this.size = 0;
@@ -54,13 +65,18 @@ class LazyBucketSortedSet {
 	_addInternal(key, item) {
 		let entry = this._map.get(key);
 		if (entry === undefined) {
-			entry = this._leaf
-				? new SortableSet(undefined, this._innerArgs[0])
-				: new /** @type {any} */ (LazyBucketSortedSet)(...this._innerArgs);
+			entry =
+				/** @type {Entry<T>} */
+				(
+					this._leaf
+						? new SortableSet(undefined, this._innerArgs[0])
+						: new /** @type {TODO} */ (LazyBucketSortedSet)(...this._innerArgs)
+				);
 			this._keys.add(key);
 			this._map.set(key, entry);
 		}
-		entry.add(item);
+		/** @type {Entry<T>} */
+		(entry).add(item);
 	}
 
 	/**
@@ -74,7 +90,7 @@ class LazyBucketSortedSet {
 			return;
 		}
 		const key = this._getKey(item);
-		const entry = this._map.get(key);
+		const entry = /** @type {Entry<T>} */ (this._map.get(key));
 		entry.delete(item);
 		if (entry.size === 0) {
 			this._deleteKey(key);
@@ -94,7 +110,7 @@ class LazyBucketSortedSet {
 	 * @returns {T | undefined} an item
 	 */
 	popFirst() {
-		if (this.size === 0) return undefined;
+		if (this.size === 0) return;
 		this.size--;
 		if (this._unsortedItems.size > 0) {
 			for (const item of this._unsortedItems) {
@@ -104,25 +120,24 @@ class LazyBucketSortedSet {
 			this._unsortedItems.clear();
 		}
 		this._keys.sort();
-		const key = first(this._keys);
+		const key = /** @type {K} */ (first(this._keys));
 		const entry = this._map.get(key);
 		if (this._leaf) {
 			const leafEntry = /** @type {SortableSet<T>} */ (entry);
 			leafEntry.sort();
-			const item = first(leafEntry);
+			const item = /** @type {T} */ (first(leafEntry));
 			leafEntry.delete(item);
 			if (leafEntry.size === 0) {
 				this._deleteKey(key);
 			}
 			return item;
-		} else {
-			const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
-			const item = nodeEntry.popFirst();
-			if (nodeEntry.size === 0) {
-				this._deleteKey(key);
-			}
-			return item;
 		}
+		const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+		const item = nodeEntry.popFirst();
+		if (nodeEntry.size === 0) {
+			this._deleteKey(key);
+		}
+		return item;
 	}
 
 	/**
@@ -135,7 +150,6 @@ class LazyBucketSortedSet {
 				if (remove) {
 					this._unsortedItems.delete(item);
 					this.size--;
-					return;
 				}
 			};
 		}
@@ -163,32 +177,31 @@ class LazyBucketSortedSet {
 					this._addInternal(newKey, item);
 				}
 			};
-		} else {
-			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
-				this._map.get(key)
-			);
-			const finishUpdate = oldEntry.startUpdate(item);
-			return remove => {
-				if (remove) {
-					this.size--;
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					return;
+		}
+		const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
+			this._map.get(key)
+		);
+		const finishUpdate = oldEntry.startUpdate(item);
+		return remove => {
+			if (remove) {
+				this.size--;
+				finishUpdate(true);
+				if (oldEntry.size === 0) {
+					this._deleteKey(key);
 				}
-				const newKey = this._getKey(item);
-				if (key === newKey) {
-					finishUpdate();
-				} else {
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					this._addInternal(newKey, item);
+				return;
+			}
+			const newKey = this._getKey(item);
+			if (key === newKey) {
+				finishUpdate();
+			} else {
+				finishUpdate(true);
+				if (oldEntry.size === 0) {
+					this._deleteKey(key);
 				}
-			};
-		}
+				this._addInternal(newKey, item);
+			}
+		};
 	}
 
 	/**
@@ -215,16 +228,19 @@ class LazyBucketSortedSet {
 	 * @returns {Iterator<T>} the iterator
 	 */
 	[Symbol.iterator]() {
+		/** @type {Iterator<T>[]} */
 		const iterators = [];
 		this._appendIterators(iterators);
 		iterators.reverse();
-		let currentIterator = iterators.pop();
+		let currentIterator =
+			/** @type {Iterator<T>} */
+			(iterators.pop());
 		return {
 			next: () => {
 				const res = currentIterator.next();
 				if (res.done) {
 					if (iterators.length === 0) return res;
-					currentIterator = iterators.pop();
+					currentIterator = /** @type {Iterator<T>} */ (iterators.pop());
 					return currentIterator.next();
 				}
 				return res;

package/lib/util/LazySet.js

@@ -138,6 +138,9 @@ class LazySet {
 		return this._set.delete(value);
 	}
 
+	/**
+	 * @returns {IterableIterator<[T, T]>} entries
+	 */
 	entries() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
@@ -152,6 +155,7 @@ class LazySet {
 	forEach(callbackFn, thisArg) {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
+		// eslint-disable-next-line unicorn/no-array-for-each
 		this._set.forEach(callbackFn, thisArg);
 	}
 
@@ -164,18 +168,27 @@ class LazySet {
 		return this._set.has(item);
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} keys
+	 */
 	keys() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
 		return this._set.keys();
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} values
+	 */
 	values() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();
 		return this._set.values();
 	}
 
+	/**
+	 * @returns {IterableIterator<T>} iterable iterator
+	 */
 	[Symbol.iterator]() {
 		this._deopt = true;
 		if (this._needMerge) this._merge();

package/lib/util/MapHelpers.js

@@ -9,14 +9,12 @@
  * getOrInsert is a helper function for maps that allows you to get a value
  * from a map if it exists, or insert a new value if it doesn't. If it value doesn't
  * exist, it will be computed by the provided function.
- *
  * @template K
  * @template V
  * @param {Map<K, V>} map The map object to check
  * @param {K} key The key to check
  * @param {function(): V} computer function which will compute the value if it doesn't exist
  * @returns {V} The value from the map, or the computed value
- *
  * @example
  * ```js
  * const map = new Map();
@@ -24,7 +22,7 @@
  * console.log(value); // "value"
  * ```
  */
-exports.getOrInsert = (map, key, computer) => {
+module.exports.getOrInsert = (map, key, computer) => {
 	// Grab key from map
 	const value = map.get(key);
 	// If the value already exists, return it

package/lib/util/ParallelismFactorCalculator.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const binarySearchBounds = require("../util/binarySearchBounds");
+const binarySearchBounds = require("./binarySearchBounds");
 
 /** @typedef {function(number): void} Callback */
 

package/lib/util/Queue.js

@@ -48,7 +48,7 @@ class Queue {
 	 */
 	dequeue() {
 		const result = this._iterator.next();
-		if (result.done) return undefined;
+		if (result.done) return;
 		this._set.delete(result.value);
 		return result.value;
 	}

package/lib/util/Semaphore.js

@@ -8,7 +8,6 @@
 class Semaphore {
 	/**
 	 * Creates an instance of Semaphore.
-	 *
 	 * @param {number} available the amount available number of "tasks"
 	 * in the Semaphore
 	 */
@@ -41,12 +40,10 @@ class Semaphore {
 	}
 
 	_continue() {
-		if (this.available > 0) {
-			if (this.waiters.length > 0) {
-				this.available--;
-				const callback = /** @type {(function(): void)} */ (this.waiters.pop());
-				callback();
-			}
+		if (this.available > 0 && this.waiters.length > 0) {
+			this.available--;
+			const callback = /** @type {(function(): void)} */ (this.waiters.pop());
+			callback();
 		}
 	}
 }

package/lib/util/SetHelpers.js

@@ -87,8 +87,8 @@ const combine = (a, b) => {
 	return set;
 };
 
-exports.intersect = intersect;
-exports.isSubset = isSubset;
-exports.find = find;
-exports.first = first;
-exports.combine = combine;
+module.exports.intersect = intersect;
+module.exports.isSubset = isSubset;
+module.exports.find = find;
+module.exports.first = first;
+module.exports.combine = combine;

package/lib/util/SortableSet.js

@@ -15,15 +15,16 @@ const NONE = Symbol("not sorted");
 class SortableSet extends Set {
 	/**
 	 * Create a new sortable set
+	 * @template T
 	 * @param {Iterable<T>=} initialIterable The initial iterable value
 	 * @typedef {function(T, T): number} SortFunction
-	 * @param {SortFunction=} defaultSort Default sorting function
+	 * @param {SortFunction<T>=} defaultSort Default sorting function
 	 */
 	constructor(initialIterable, defaultSort) {
 		super(initialIterable);
 		/**
 		 * @private
-		 * @type {undefined | function(T, T): number}}
+		 * @type {undefined | SortFunction<T>}
 		 */
 		this._sortFn = defaultSort;
 		/**
@@ -76,7 +77,7 @@ class SortableSet extends Set {
 
 	/**
 	 * Sort with a comparer function
-	 * @param {SortFunction} sortFn Sorting comparer function
+	 * @param {SortFunction<T> | undefined} sortFn Sorting comparer function
 	 * @returns {void}
 	 */
 	sortWith(sortFn) {

package/lib/util/StackedCacheMap.js

@@ -6,9 +6,6 @@
 "use strict";
 
 /**
- * @template K
- * @template V
- *
  * The StackedCacheMap is a data structure designed as an alternative to a Map
  * in situations where you need to handle multiple item additions and
  * frequently access the largest map.
@@ -19,7 +16,6 @@
  * It has a fallback Map that is used when the map to be added is mutable.
  *
  * Note: `delete` and `has` are not supported for performance reasons.
- *
  * @example
  * ```js
  * const map = new StackedCacheMap();
@@ -31,6 +27,8 @@
  * 		console.log(key, value);
  * }
  * ```
+ * @template K
+ * @template V
  */
 class StackedCacheMap {
 	constructor() {
@@ -94,7 +92,7 @@ class StackedCacheMap {
 
 	/**
 	 * @param {K} item the key of the element to return
-	 * @returns {V} the value of the element
+	 * @returns {V | undefined} the value of the element
 	 */
 	get(item) {
 		for (const map of this.stack) {
@@ -130,7 +128,7 @@ class StackedCacheMap {
 			next() {
 				let result = current.next();
 				while (result.done && iterators.length > 0) {
-					current = iterators.pop();
+					current = /** @type {IterableIterator<[K, V]>} */ (iterators.pop());
 					result = current.next();
 				}
 				return result;

package/lib/util/StackedMap.js

@@ -29,9 +29,8 @@ const extractPair = pair => {
 	const val = pair[1];
 	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
 		return [key, undefined];
-	} else {
-		return /** @type {[K, Cell<V>]} */ (pair);
 	}
+	return /** @type {[K, Cell<V>]} */ (pair);
 };
 
 /**
@@ -116,7 +115,6 @@ class StackedMap {
 			}
 			this.map.set(item, TOMBSTONE);
 		}
-		return undefined;
 	}
 
 	_compress() {

package/lib/util/StringXor.js

@@ -17,7 +17,6 @@
  * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
  * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
  * Module hashes.
- *
  * @example
  * ```js
  * const xor = new StringXor();
@@ -25,7 +24,6 @@
  * xor.add('world');
  * console.log(xor.toString());
  * ```
- *
  * @example
  * ```js
  * const xor = new StringXor();
@@ -44,7 +42,6 @@ class StringXor {
 
 	/**
 	 * Adds a string to the current StringXor object.
-	 *
 	 * @param {string} str string
 	 * @returns {void}
 	 */
@@ -84,7 +81,6 @@ class StringXor {
 	 * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
 	 * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
 	 * with binary data that needs to be represented as a string.
-	 *
 	 * @returns {string} Returns a string that represents the current state of the StringXor object.
 	 */
 	toString() {
@@ -94,7 +90,6 @@ class StringXor {
 
 	/**
 	 * Updates the hash with the current state of the StringXor object.
-	 *
 	 * @param {Hash} hash Hash instance
 	 */
 	updateHash(hash) {

package/lib/util/TupleQueue.js

@@ -57,7 +57,7 @@ class TupleQueue {
 				this._set.delete(...value);
 				return value;
 			}
-			return undefined;
+			return;
 		}
 		this._set.delete(...result.value);
 		return result.value;

package/lib/util/TupleSet.js

@@ -9,7 +9,11 @@
  * @template {any[]} T
  */
 class TupleSet {
+	/**
+	 * @param {Iterable<T>=} init init
+	 */
 	constructor(init) {
+		/** @type {Map<T, TODO>} */
 		this._map = new Map();
 		this.size = 0;
 		if (init) {
@@ -62,7 +66,7 @@ class TupleSet {
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		const set = map.get(beforeLast);
 		if (set === undefined) {
 			return false;
 		}
@@ -86,7 +90,7 @@ class TupleSet {
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		const set = map.get(beforeLast);
 		if (set === undefined) {
 			return;
 		}
@@ -101,10 +105,17 @@ class TupleSet {
 	 * @returns {Iterator<T>} iterator
 	 */
 	[Symbol.iterator]() {
+		/** @type {TODO[]} */
 		const iteratorStack = [];
+		/** @type {T[]} */
 		const tuple = [];
-		let currentSetIterator = undefined;
+		/** @type {Iterator<T> | undefined} */
+		let currentSetIterator;
 
+		/**
+		 * @param {TODO} it iterator
+		 * @returns {boolean} result
+		 */
 		const next = it => {
 			const result = it.next();
 			if (result.done) {
@@ -118,9 +129,8 @@ class TupleSet {
 			if (value instanceof Set) {
 				currentSetIterator = value[Symbol.iterator]();
 				return true;
-			} else {
-				return next(value[Symbol.iterator]());
 			}
+			return next(value[Symbol.iterator]());
 		};
 
 		next(this._map[Symbol.iterator]());