webpack 5.59.0 → 5.94.0

package/lib/util/ArrayQueue.js

@@ -13,9 +13,15 @@ class ArrayQueue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {T[]} */
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
 		this._list = items ? Array.from(items) : [];
-		/** @private @type {T[]} */
+		/**
+		 * @private
+		 * @type {T[]}
+		 */
 		this._listReversed = [];
 	}
 
@@ -50,7 +56,7 @@ class ArrayQueue {
 	 */
 	dequeue() {
 		if (this._listReversed.length === 0) {
-			if (this._list.length === 0) return undefined;
+			if (this._list.length === 0) return;
 			if (this._list.length === 1) return this._list.pop();
 			if (this._list.length < 16) return this._list.shift();
 			const temp = this._listReversed;
@@ -77,31 +83,18 @@ class ArrayQueue {
 	}
 
 	[Symbol.iterator]() {
-		let i = -1;
-		let reversed = false;
 		return {
 			next: () => {
-				if (!reversed) {
-					i++;
-					if (i < this._list.length) {
-						return {
-							done: false,
-							value: this._list[i]
-						};
-					}
-					reversed = true;
-					i = this._listReversed.length;
-				}
-				i--;
-				if (i < 0) {
+				const item = this.dequeue();
+				if (item) {
 					return {
-						done: true,
-						value: undefined
+						done: false,
+						value: item
 					};
 				}
 				return {
-					done: false,
-					value: this._listReversed[i]
+					done: true,
+					value: undefined
 				};
 			}
 		};

package/lib/util/AsyncQueue.js

@@ -19,8 +19,8 @@ let inHandleResult = 0;
 /**
  * @template T
  * @callback Callback
- * @param {WebpackError=} err
- * @param {T=} result
+ * @param {(WebpackError | null)=} err
+ * @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
@@ -53,29 +65,31 @@ class AsyncQueueEntry {
  */
 class AsyncQueue {
 	/**
-	 * @param {Object} options options object
+	 * @param {object} options options object
 	 * @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>>} */
 		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[]} */
+		/** @type {AsyncQueue<any, any, any>[] | undefined} */
 		this._children = undefined;
 		this._activeTasks = 0;
 		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"])
 		};
 
@@ -159,7 +173,9 @@ class AsyncQueue {
 	 */
 	invalidate(item) {
 		const key = this._getKey(item);
-		const entry = this._entries.get(key);
+		const entry =
+			/** @type {AsyncQueueEntry<T, K, R>} */
+			(this._entries.get(key));
 		this._entries.delete(key);
 		if (entry.state === QUEUED_STATE) {
 			this._queued.delete(entry);
@@ -200,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")
+			);
 		}
 	}
 
@@ -306,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);
 		});
@@ -314,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) {
@@ -324,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

@@ -87,7 +87,7 @@ class LazySet {
 
 	/**
 	 * @param {T} item an item
-	 * @returns {this} itself
+	 * @returns {LazySet<T>} itself
 	 */
 	add(item) {
 		this._set.add(item);
@@ -96,7 +96,7 @@ class LazySet {
 
 	/**
 	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
-	 * @returns {this} itself
+	 * @returns {LazySet<T>} itself
 	 */
 	addAll(iterable) {
 		if (this._deopt) {
@@ -152,6 +152,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);
 	}
 
@@ -187,12 +188,20 @@ class LazySet {
 		return "LazySet";
 	}
 
+	/**
+	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext} context context
+	 */
 	serialize({ write }) {
 		if (this._needMerge) this._merge();
 		write(this._set.size);
 		for (const item of this._set) write(item);
 	}
 
+	/**
+	 * @template T
+	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} context context
+	 * @returns {LazySet<T>} lazy set
+	 */
 	static deserialize({ read }) {
 		const count = read();
 		const items = [];

package/lib/util/MapHelpers.js

@@ -6,16 +6,28 @@
 "use strict";
 
 /**
+ * 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 a map
- * @param {K} key the key
- * @param {function(): V} computer compute value
- * @returns {V} value
+ * @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();
+ * const value = getOrInsert(map, "key", () => "value");
+ * console.log(value); // "value"
+ * ```
  */
-exports.provide = (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
 	if (value !== undefined) return value;
+	// Otherwise compute the value, set it in the map, and return it
 	const newValue = computer();
 	map.set(key, newValue);
 	return newValue;

package/lib/util/ParallelismFactorCalculator.js

@@ -5,14 +5,24 @@
 
 "use strict";
 
-const binarySearchBounds = require("../util/binarySearchBounds");
+const binarySearchBounds = require("./binarySearchBounds");
+
+/** @typedef {function(number): void} Callback */
 
 class ParallelismFactorCalculator {
 	constructor() {
+		/** @type {number[]} */
 		this._rangePoints = [];
+		/** @type {Callback[]} */
 		this._rangeCallbacks = [];
 	}
 
+	/**
+	 * @param {number} start range start
+	 * @param {number} end range end
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
 	range(start, end, callback) {
 		if (start === end) return callback(1);
 		this._rangePoints.push(start);

package/lib/util/Queue.js

@@ -13,9 +13,15 @@ class Queue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {Set<T>} */
+		/**
+		 * @private
+		 * @type {Set<T>}
+		 */
 		this._set = new Set(items);
-		/** @private @type {Iterator<T>} */
+		/**
+		 * @private
+		 * @type {Iterator<T>}
+		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
 
@@ -42,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 = 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,19 +15,32 @@ 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}} */
+		/**
+		 * @private
+		 * @type {undefined | SortFunction<T>}
+		 */
 		this._sortFn = defaultSort;
-		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
+		/**
+		 * @private
+		 * @type {typeof NONE | undefined | function(T, T): number}}
+		 */
 		this._lastActiveSortFn = NONE;
-		/** @private @type {Map<Function, any> | undefined} */
+		/**
+		 * @private
+		 * @type {Map<Function, any> | undefined}
+		 */
 		this._cache = undefined;
-		/** @private @type {Map<Function, any> | undefined} */
+		/**
+		 * @private
+		 * @type {Map<Function, any> | undefined}
+		 */
 		this._cacheOrderIndependent = undefined;
 	}
 
@@ -64,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) {