@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/util/AsyncQueue.js

@@ -6,8 +6,8 @@
 "use strict";
 
 const { AsyncSeriesHook, SyncHook } = require("tapable");
-const { makeWebpackError } = require("../HookWebpackError");
-const WebpackError = require("../WebpackError");
+const { makeWebpackError } = require("../errors/HookWebpackError");
+const WebpackError = require("../errors/WebpackError");
 const ArrayQueue = require("./ArrayQueue");
 
 const QUEUED_STATE = 0;
@@ -17,6 +17,7 @@ const DONE_STATE = 2;
 let inHandleResult = 0;
 
 /**
+ * Defines the callback callback.
  * @template T
  * @callback Callback
  * @param {(WebpackError | null)=} err
@@ -25,16 +26,19 @@ let inHandleResult = 0;
  */
 
 /**
+ * Represents AsyncQueueEntry.
  * @template T
  * @template K
  * @template R
  */
 class AsyncQueueEntry {
 	/**
+	 * Creates an instance of AsyncQueueEntry.
 	 * @param {T} item the item
 	 * @param {Callback<R>} callback the callback
 	 */
 	constructor(item, callback) {
+		/** @type {T} */
 		this.item = item;
 		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
 		this.state = QUEUED_STATE;
@@ -50,22 +54,26 @@ class AsyncQueueEntry {
 }
 
 /**
+ * Defines the get key type used by this module.
  * @template T, K
  * @typedef {(item: T) => K} getKey
  */
 
 /**
+ * Defines the processor type used by this module.
  * @template T, R
  * @typedef {(item: T, callback: Callback<R>) => void} Processor
  */
 
 /**
+ * Represents AsyncQueue.
  * @template T
  * @template K
  * @template R
  */
 class AsyncQueue {
 	/**
+	 * Creates an instance of AsyncQueue.
 	 * @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
@@ -75,10 +83,15 @@ class AsyncQueue {
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
 	constructor({ name, context, parallelism, parent, processor, getKey }) {
+		/** @type {string | undefined} */
 		this._name = name;
+		/** @type {string} */
 		this._context = context || "normal";
+		/** @type {number} */
 		this._parallelism = parallelism || 1;
+		/** @type {Processor<T, R>} */
 		this._processor = processor;
+		/** @type {getKey<T, K>} */
 		this._getKey =
 			getKey ||
 			/** @type {getKey<T, K>} */ ((item) => /** @type {T & K} */ (item));
@@ -88,9 +101,13 @@ class AsyncQueue {
 		this._queued = new ArrayQueue();
 		/** @type {AsyncQueue<T, K, R>[] | undefined} */
 		this._children = undefined;
+		/** @type {number} */
 		this._activeTasks = 0;
+		/** @type {boolean} */
 		this._willEnsureProcessing = false;
+		/** @type {boolean} */
 		this._needProcessing = false;
+		/** @type {boolean} */
 		this._stopped = false;
 		/** @type {AsyncQueue<T, K, R>} */
 		this._root = parent ? parent._root : this;
@@ -119,6 +136,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Returns context of execution.
 	 * @returns {string} context of execution
 	 */
 	getContext() {
@@ -126,6 +144,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Updates context using the provided value.
 	 * @param {string} value context of execution
 	 */
 	setContext(value) {
@@ -133,12 +152,18 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided item.
 	 * @param {T} item an item
 	 * @param {Callback<R>} callback callback function
 	 * @returns {void}
 	 */
 	add(item, callback) {
 		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeAdd.isUsed()) {
+			this._add(item, callback);
+			return;
+		}
 		this.hooks.beforeAdd.callAsync(item, (err) => {
 			if (err) {
 				callback(
@@ -146,45 +171,56 @@ class AsyncQueue {
 				);
 				return;
 			}
-			const key = this._getKey(item);
-			const entry = this._entries.get(key);
-			if (entry !== undefined) {
-				if (entry.state === DONE_STATE) {
-					if (inHandleResult++ > 3) {
-						process.nextTick(() => callback(entry.error, entry.result));
-					} else {
-						callback(entry.error, entry.result);
-					}
-					inHandleResult--;
-				} else if (entry.callbacks === undefined) {
-					entry.callbacks = [callback];
+			this._add(item, callback);
+		});
+	}
+
+	/**
+	 * Processes the provided item, after the beforeAdd hook.
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	_add(item, callback) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		if (entry !== undefined) {
+			if (entry.state === DONE_STATE) {
+				if (inHandleResult++ > 3) {
+					process.nextTick(() => callback(entry.error, entry.result));
 				} else {
-					entry.callbacks.push(callback);
+					callback(entry.error, entry.result);
 				}
-				return;
-			}
-			const newEntry = new AsyncQueueEntry(item, callback);
-			if (this._stopped) {
-				this.hooks.added.call(item);
-				this._root._activeTasks++;
-				process.nextTick(() =>
-					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
-				);
+				inHandleResult--;
+			} else if (entry.callbacks === undefined) {
+				entry.callbacks = [callback];
 			} else {
-				this._entries.set(key, newEntry);
-				this._queued.enqueue(newEntry);
-				const root = this._root;
-				root._needProcessing = true;
-				if (root._willEnsureProcessing === false) {
-					root._willEnsureProcessing = true;
-					setImmediate(root._ensureProcessing);
-				}
-				this.hooks.added.call(item);
+				entry.callbacks.push(callback);
 			}
-		});
+			return;
+		}
+		const newEntry = new AsyncQueueEntry(item, callback);
+		if (this._stopped) {
+			this.hooks.added.call(item);
+			this._root._activeTasks++;
+			process.nextTick(() =>
+				this._handleResult(newEntry, new WebpackError("Queue was stopped"))
+			);
+		} else {
+			this._entries.set(key, newEntry);
+			this._queued.enqueue(newEntry);
+			const root = this._root;
+			root._needProcessing = true;
+			if (root._willEnsureProcessing === false) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
+			}
+			this.hooks.added.call(item);
+		}
 	}
 
 	/**
+	 * Processes the provided item.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -225,6 +261,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Describes how this stop operation behaves.
 	 * @returns {void}
 	 */
 	stop() {
@@ -245,6 +282,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Increase parallelism.
 	 * @returns {void}
 	 */
 	increaseParallelism() {
@@ -258,6 +296,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Decrease parallelism.
 	 * @returns {void}
 	 */
 	decreaseParallelism() {
@@ -266,6 +305,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is processing.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently being processed
 	 */
@@ -276,6 +316,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is queued.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently queued
 	 */
@@ -286,6 +327,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Checks whether this async queue is done.
 	 * @param {T} item an item
 	 * @returns {boolean} true, if the item is currently queued
 	 */
@@ -296,6 +338,7 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Describes how this ensure processing operation behaves.
 	 * @returns {void}
 	 */
 	_ensureProcessing() {
@@ -324,10 +367,16 @@ class AsyncQueue {
 	}
 
 	/**
+	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
 	 * @returns {void}
 	 */
 	_startProcessing(entry) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.beforeStart.isUsed()) {
+			this._startProcessing2(entry);
+			return;
+		}
 		this.hooks.beforeStart.callAsync(entry.item, (err) => {
 			if (err) {
 				this._handleResult(
@@ -336,66 +385,97 @@ class AsyncQueue {
 				);
 				return;
 			}
-			let inCallback = false;
-			try {
-				this._processor(entry.item, (e, r) => {
-					inCallback = true;
-					this._handleResult(entry, e, r);
-				});
-			} catch (err) {
-				if (inCallback) throw err;
-				this._handleResult(entry, /** @type {WebpackError} */ (err), null);
-			}
-			this.hooks.started.call(entry.item);
+			this._startProcessing2(entry);
 		});
 	}
 
 	/**
+	 * Processes the provided entry, after the beforeStart hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @returns {void}
+	 */
+	_startProcessing2(entry) {
+		let inCallback = false;
+		try {
+			this._processor(entry.item, (e, r) => {
+				inCallback = true;
+				this._handleResult(entry, e, r);
+			});
+		} catch (err) {
+			if (inCallback) throw err;
+			this._handleResult(entry, /** @type {WebpackError} */ (err), null);
+		}
+		this.hooks.started.call(entry.item);
+	}
+
+	/**
+	 * Processes the provided entry.
 	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
 	 * @param {(WebpackError | null)=} err error, if any
 	 * @param {(R | null)=} result result, if any
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
+		// skip async hook dispatch when unused — this runs per module × queue
+		if (!this.hooks.result.isUsed()) {
+			this._handleResult2(entry, err, result);
+			return;
+		}
 		this.hooks.result.callAsync(entry.item, err, result, (hookError) => {
-			const error = hookError
-				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
-				: err;
-
-			const callback = /** @type {Callback<R>} */ (entry.callback);
-			const callbacks = entry.callbacks;
-			entry.state = DONE_STATE;
-			entry.callback = undefined;
-			entry.callbacks = undefined;
-			entry.result = result;
-			entry.error = error;
+			this._handleResult2(
+				entry,
+				hookError
+					? makeWebpackError(
+							hookError,
+							`AsyncQueue(${this._name}).hooks.result`
+						)
+					: err,
+				result
+			);
+		});
+	}
 
-			const root = this._root;
-			root._activeTasks--;
-			if (root._willEnsureProcessing === false && root._needProcessing) {
-				root._willEnsureProcessing = true;
-				setImmediate(root._ensureProcessing);
-			}
+	/**
+	 * Finalizes the provided entry, after the result hook.
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @param {(WebpackError | null)=} error error, if any
+	 * @param {(R | null)=} result result, if any
+	 * @returns {void}
+	 */
+	_handleResult2(entry, error, result) {
+		const callback = /** @type {Callback<R>} */ (entry.callback);
+		const callbacks = entry.callbacks;
+		entry.state = DONE_STATE;
+		entry.callback = undefined;
+		entry.callbacks = undefined;
+		entry.result = result;
+		entry.error = error;
 
-			if (inHandleResult++ > 3) {
-				process.nextTick(() => {
-					callback(error, result);
-					if (callbacks !== undefined) {
-						for (const callback of callbacks) {
-							callback(error, result);
-						}
-					}
-				});
-			} else {
+		const root = this._root;
+		root._activeTasks--;
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
+		}
+
+		if (inHandleResult++ > 3) {
+			process.nextTick(() => {
 				callback(error, result);
 				if (callbacks !== undefined) {
 					for (const callback of callbacks) {
 						callback(error, result);
 					}
 				}
+			});
+		} else {
+			callback(error, result);
+			if (callbacks !== undefined) {
+				for (const callback of callbacks) {
+					callback(error, result);
+				}
 			}
-			inHandleResult--;
-		});
+		}
+		inHandleResult--;
 	}
 
 	clear() {

package/lib/util/Hash.js

@@ -33,7 +33,7 @@ class Hash {
 	 * @returns {Hash} updated hash
 	 */
 	update(data, inputEncoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
@@ -59,7 +59,7 @@ class Hash {
 	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/util/IterableHelpers.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /**
+ * Returns last item.
  * @template T
  * @param {Iterable<T>} set a set
  * @returns {T | undefined} last item
@@ -18,6 +19,7 @@ const last = (set) => {
 };
 
 /**
+ * Returns true, if some items match the filter predicate.
  * @template T
  * @param {Iterable<T>} iterable iterable
  * @param {(value: T) => boolean | null | undefined} filter predicate
@@ -31,6 +33,7 @@ const someInIterable = (iterable, filter) => {
 };
 
 /**
+ * Returns count of items.
  * @template T
  * @param {Iterable<T>} iterable an iterable
  * @returns {number} count of items

package/lib/util/LazyBucketSortedSet.js

@@ -9,23 +9,28 @@ const { first } = require("./SetHelpers");
 const SortableSet = require("./SortableSet");
 
 /**
+ * Callback that extracts the grouping key for an item at one bucket layer.
  * @template T
  * @template K
  * @typedef {(item: T) => K} GetKey
  */
 
 /**
+ * Comparison function used to order keys or leaf items.
  * @template T
  * @typedef {(a: T, n: T) => number} Comparator
  */
 
 /**
+ * Internal bucket entry, either another nested bucket set or a sorted leaf set.
  * @template T
  * @template K
  * @typedef {LazyBucketSortedSet<T, K> | SortableSet<T>} Entry
  */
 
 /**
+ * Constructor argument accepted for nested bucket layers or the final leaf
+ * comparator.
  * @template T
  * @template K
  * @typedef {GetKey<T, K> | Comparator<K> | Comparator<T>} Arg
@@ -45,23 +50,32 @@ const SortableSet = require("./SortableSet");
  */
 class LazyBucketSortedSet {
 	/**
+	 * Creates a lazily sorted, potentially multi-level bucket structure whose
+	 * order is only fully resolved when items are popped.
 	 * @param {GetKey<T, K>} getKey function to get key from item
 	 * @param {Comparator<K>=} comparator comparator to sort keys
 	 * @param {...Arg<T, K>} args more pairs of getKey and comparator plus optional final comparator for the last layer
 	 */
 	constructor(getKey, comparator, ...args) {
+		/** @type {GetKey<T, K>} */
 		this._getKey = getKey;
+		/** @type {Arg<T, K>[]} */
 		this._innerArgs = args;
+		/** @type {boolean} */
 		this._leaf = args.length <= 1;
+		/** @type {SortableSet<K>} */
 		this._keys = new SortableSet(undefined, comparator);
 		/** @type {Map<K, Entry<T, K>>} */
 		this._map = new Map();
 		/** @type {Set<T>} */
 		this._unsortedItems = new Set();
+		/** @type {number} */
 		this.size = 0;
 	}
 
 	/**
+	 * Adds an item to the unsorted staging area so sorting can be deferred until
+	 * an ordered pop is requested.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -71,6 +85,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Inserts an item into the correct nested bucket, creating intermediate
+	 * bucket structures on demand.
 	 * @param {K} key key of item
 	 * @param {T} item the item
 	 * @returns {void}
@@ -95,6 +111,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes an item from either the unsorted staging area or its resolved
+	 * bucket and prunes empty buckets as needed.
 	 * @param {T} item an item
 	 * @returns {void}
 	 */
@@ -113,6 +131,7 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes an empty bucket key and its corresponding nested entry.
 	 * @param {K} key key to be removed
 	 * @returns {void}
 	 */
@@ -122,6 +141,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Removes and returns the smallest item according to the configured bucket
+	 * order, sorting only the portions of the structure that are needed.
 	 * @returns {T | undefined} an item
 	 */
 	popFirst() {
@@ -158,6 +179,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Begins an in-place update for an item and returns a completion callback
+	 * that can either reinsert it under a new key or remove it entirely.
 	 * @param {T} item to be updated item
 	 * @returns {(remove?: true) => void} finish update
 	 */
@@ -222,6 +245,8 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Appends iterators for every stored bucket and leaf to support unordered
+	 * traversal across the entire structure.
 	 * @param {Iterator<T>[]} iterators list of iterators to append to
 	 * @returns {void}
 	 */
@@ -245,6 +270,7 @@ class LazyBucketSortedSet {
 	}
 
 	/**
+	 * Iterates over all stored items without imposing bucket sort order.
 	 * @returns {Iterator<T>} the iterator
 	 */
 	[Symbol.iterator]() {