webpack 5.99.5 → 5.99.7

package/lib/stats/StatsFactory.js

@@ -10,13 +10,33 @@ const { concatComparators, keepOriginalOrder } = require("../util/comparators");
 const smartGrouping = require("../util/smartGrouping");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph").ModuleProfile} ModuleProfile */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/comparators").Comparator<TODO>} Comparator */
+/** @typedef {import("../util/comparators").Comparator<EXPECTED_ANY>} Comparator */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/smartGrouping").GroupConfig<TODO, EXPECTED_OBJECT>} GroupConfig */
+/** @typedef {import("../util/smartGrouping").GroupConfig<EXPECTED_ANY, EXPECTED_OBJECT>} GroupConfig */
+/** @typedef {import("./DefaultStatsFactoryPlugin").ChunkGroupInfoWithName} ChunkGroupInfoWithName */
+/** @typedef {import("./DefaultStatsFactoryPlugin").ModuleIssuerPath} ModuleIssuerPath */
+/** @typedef {import("./DefaultStatsFactoryPlugin").ModuleTrace} ModuleTrace */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
 /**
  * @typedef {object} KnownStatsFactoryContext
@@ -33,11 +53,24 @@ const smartGrouping = require("../util/smartGrouping");
 
 /** @typedef {KnownStatsFactoryContext & Record<string, EXPECTED_ANY>} StatsFactoryContext */
 
-/** @typedef {any} CreatedObject */
-/** @typedef {any} FactoryData */
-/** @typedef {any} FactoryDataItem */
-/** @typedef {any} Result */
-/** @typedef {Record<string, any>} ObjectForExtract */
+// StatsLogging StatsLoggingEntry
+
+/**
+ * @template T
+ * @template F
+ * @typedef {T extends Compilation ? StatsCompilation : T extends ChunkGroupInfoWithName ? StatsChunkGroup : T extends Chunk ? StatsChunk : T extends OriginRecord ? StatsChunkOrigin : T extends Module ? StatsModule : T extends ModuleGraphConnection ? StatsModuleReason : T extends Asset ? StatsAsset : T extends ModuleTrace ? StatsModuleTraceItem : T extends Dependency ? StatsModuleTraceDependency : T extends Error ? StatsError : T extends ModuleProfile ? StatsProfile : F} StatsObject
+ */
+
+/**
+ * @template T
+ * @template F
+ * @typedef {T extends ChunkGroupInfoWithName[] ? Record<string, StatsObject<ChunkGroupInfoWithName, F>> : T extends (infer V)[] ? StatsObject<V, F>[] : StatsObject<T, F>} CreatedObject
+ */
+
+/** @typedef {TODO} FactoryData */
+/** @typedef {TODO} FactoryDataItem */
+/** @typedef {TODO} Result */
+/** @typedef {Record<string, TODO>} ObjectForExtract */
 
 /**
  * @typedef {object} StatsFactoryHooks
@@ -188,10 +221,12 @@ class StatsFactory {
 	}
 
 	/**
+	 * @template FactoryData
+	 * @template FallbackCreatedObject
 	 * @param {string} type type
 	 * @param {FactoryData} data factory data
 	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
-	 * @returns {CreatedObject} created object
+	 * @returns {CreatedObject<FactoryData, FallbackCreatedObject>} created object
 	 */
 	create(type, data, baseContext) {
 		if (this._inCreate) {
@@ -208,11 +243,13 @@ class StatsFactory {
 	}
 
 	/**
+	 * @private
+	 * @template FactoryData
+	 * @template FallbackCreatedObject
 	 * @param {string} type type
 	 * @param {FactoryData} data factory data
 	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
-	 * @returns {CreatedObject} created object
-	 * @private
+	 * @returns {CreatedObject<FactoryData, FallbackCreatedObject>} created object
 	 */
 	_create(type, data, baseContext) {
 		const context = /** @type {StatsFactoryContext} */ ({

package/lib/stats/StatsPrinter.js

@@ -23,7 +23,7 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
 /**
  * @typedef {object} PrintedElement
  * @property {string} element
- * @property {string} content
+ * @property {string | undefined} content
  */
 
 /**
@@ -44,14 +44,16 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
  * @property {StatsModuleTraceDependency=} moduleTraceDependency
  */
 
+/** @typedef {(value: string | number) => string} ColorFunction */
+
 /**
- * @typedef {object} KnownStatsPrinterColorFn
- * @property {(str: string) => string=} bold
- * @property {(str: string) => string=} yellow
- * @property {(str: string) => string=} red
- * @property {(str: string) => string=} green
- * @property {(str: string) => string=} magenta
- * @property {(str: string) => string=} cyan
+ * @typedef {object} KnownStatsPrinterColorFunctions
+ * @property {ColorFunction=} bold
+ * @property {ColorFunction=} yellow
+ * @property {ColorFunction=} red
+ * @property {ColorFunction=} green
+ * @property {ColorFunction=} magenta
+ * @property {ColorFunction=} cyan
  */
 
 /**
@@ -67,17 +69,18 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
  * @property {(message: string) => string=} formatError
  */
 
-/** @typedef {KnownStatsPrinterColorFn & KnownStatsPrinterFormatters & KnownStatsPrinterContext & Record<string, EXPECTED_ANY>} StatsPrinterContext */
-/** @typedef {TODO} PrintObject */
+/** @typedef {KnownStatsPrinterColorFunctions & KnownStatsPrinterFormatters & KnownStatsPrinterContext & Record<string, EXPECTED_ANY>} StatsPrinterContext */
+/** @typedef {StatsPrinterContext & Required<KnownStatsPrinterColorFunctions> & Required<KnownStatsPrinterFormatters> & { type: string }} StatsPrinterContextWithExtra */
+/** @typedef {EXPECTED_ANY} PrintObject */
 
 /**
  * @typedef {object} StatsPrintHooks
  * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>} sortElements
- * @property {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string | void>>} printElements
+ * @property {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string | undefined | void>>} printElements
  * @property {HookMap<SyncBailHook<[PrintObject[], StatsPrinterContext], boolean | void>>} sortItems
  * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | void>>} getItemName
- * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], string | void>>} printItems
- * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | void>>} print
+ * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], string | undefined>>} printItems
+ * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | undefined | void>>} print
  * @property {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} result
  */
 
@@ -97,7 +100,6 @@ class StatsPrinter {
 				() => new SyncBailHook(["printedItems", "context"])
 			),
 			print: new HookMap(() => new SyncBailHook(["object", "context"])),
-			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
 			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
 		});
 		/**
@@ -147,13 +149,13 @@ class StatsPrinter {
 	 * @template {H extends import("tapable").Hook<any, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {string} type type
-	 * @param {(hooK: H) => R | void} fn fn
-	 * @returns {R | void} hook
+	 * @param {(hooK: H) => R | undefined | void} fn fn
+	 * @returns {R | undefined} hook
 	 */
 	_forEachLevel(hookMap, type, fn) {
 		for (const hook of this._getAllLevelHooks(hookMap, type)) {
 			const result = fn(/** @type {H} */ (hook));
-			if (result !== undefined) return result;
+			if (result !== undefined) return /** @type {R} */ (result);
 		}
 	}
 
@@ -166,7 +168,7 @@ class StatsPrinter {
 	 * @param {string} type type
 	 * @param {string} data data
 	 * @param {(hook: H, data: string) => string} fn fn
-	 * @returns {string} result of `fn`
+	 * @returns {string | undefined} result of `fn`
 	 */
 	_forEachLevelWaterfall(hookMap, type, data, fn) {
 		for (const hook of this._getAllLevelHooks(hookMap, type)) {
@@ -179,7 +181,7 @@ class StatsPrinter {
 	 * @param {string} type The type
 	 * @param {PrintObject} object Object to print
 	 * @param {StatsPrinterContext=} baseContext The base context
-	 * @returns {string} printed result
+	 * @returns {string | undefined} printed result
 	 */
 	print(type, object, baseContext) {
 		if (this._inPrint) {
@@ -199,7 +201,7 @@ class StatsPrinter {
 	 * @param {string} type type
 	 * @param {PrintObject} object object
 	 * @param {StatsPrinterContext=} baseContext context
-	 * @returns {string} printed result
+	 * @returns {string | undefined} printed result
 	 */
 	_print(type, object, baseContext) {
 		/** @type {StatsPrinterContext} */
@@ -209,6 +211,7 @@ class StatsPrinter {
 			[type]: object
 		};
 
+		/** @type {string | undefined} */
 		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
 			hook.call(object, context)
 		);
@@ -216,14 +219,19 @@ class StatsPrinter {
 			if (Array.isArray(object)) {
 				const sortedItems = object.slice();
 				this._forEachLevel(this.hooks.sortItems, type, h =>
-					h.call(sortedItems, context)
+					h.call(
+						sortedItems,
+						/** @type {StatsPrinterContextWithExtra} */
+						(context)
+					)
 				);
 				const printedItems = sortedItems.map((item, i) => {
-					/** @type {StatsPrinterContext} */
-					const itemContext = {
-						...context,
-						_index: i
-					};
+					const itemContext =
+						/** @type {StatsPrinterContextWithExtra} */
+						({
+							...context,
+							_index: i
+						});
 					const itemName = this._forEachLevel(
 						this.hooks.getItemName,
 						`${type}[]`,
@@ -237,7 +245,11 @@ class StatsPrinter {
 					);
 				});
 				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
-					h.call(printedItems, context)
+					h.call(
+						/** @type {string[]} */ (printedItems),
+						/** @type {StatsPrinterContextWithExtra} */
+						(context)
+					)
 				);
 				if (printResult === undefined) {
 					const result = printedItems.filter(Boolean);
@@ -248,7 +260,11 @@ class StatsPrinter {
 					key => object[key] !== undefined
 				);
 				this._forEachLevel(this.hooks.sortElements, type, h =>
-					h.call(elements, context)
+					h.call(
+						elements,
+						/** @type {StatsPrinterContextWithExtra} */
+						(context)
+					)
 				);
 				const printedElements = elements.map(element => {
 					const content = this.print(`${type}.${element}`, object[element], {
@@ -260,7 +276,11 @@ class StatsPrinter {
 					return { element, content };
 				});
 				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
-					h.call(printedElements, context)
+					h.call(
+						printedElements,
+						/** @type {StatsPrinterContextWithExtra} */
+						(context)
+					)
 				);
 				if (printResult === undefined) {
 					const result = printedElements.map(e => e.content).filter(Boolean);
@@ -272,8 +292,9 @@ class StatsPrinter {
 		return this._forEachLevelWaterfall(
 			this.hooks.result,
 			type,
-			/** @type {string} */ (printResult),
-			(h, r) => h.call(r, context)
+			/** @type {string} */
+			(printResult),
+			(h, r) => h.call(r, /** @type {StatsPrinterContextWithExtra} */ (context))
 		);
 	}
 }

package/lib/util/ArrayQueue.js

@@ -10,7 +10,7 @@
  */
 class ArrayQueue {
 	/**
-	 * @param {Iterable<T>} [items] The initial elements.
+	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
 		/**

package/lib/util/AsyncQueue.js

@@ -69,7 +69,7 @@ class AsyncQueue {
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
 	 * @param {string=} options.context context of execution
-	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
+	 * @param {AsyncQueue<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
 	 * @param {getKey<T, K>=} options.getKey extract key from item
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */

package/lib/util/TupleQueue.js

@@ -13,17 +13,17 @@ const TupleSet = require("./TupleSet");
  */
 class TupleQueue {
 	/**
-	 * @param {Iterable<[T, V]>=} items The initial elements.
+	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} items The initial elements.
 	 */
 	constructor(items) {
 		/**
 		 * @private
-		 * @type {TupleSet<[T, V]>}
+		 * @type {TupleSet<T, V>}
 		 */
 		this._set = new TupleSet(items);
 		/**
 		 * @private
-		 * @type {Iterator<[T, V]>}
+		 * @type {Iterator<[T, V, ...EXPECTED_ANY]>}
 		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
@@ -38,7 +38,7 @@ class TupleQueue {
 
 	/**
 	 * Appends the specified element to this queue.
-	 * @param {[T, V]} item The element to add.
+	 * @param {[T, V, ...EXPECTED_ANY]} item The element to add.
 	 * @returns {void}
 	 */
 	enqueue(...item) {
@@ -47,20 +47,22 @@ class TupleQueue {
 
 	/**
 	 * Retrieves and removes the head of this queue.
-	 * @returns {[T, V] | undefined} The head of the queue of `undefined` if this queue is empty.
+	 * @returns {[T, V, ...EXPECTED_ANY] | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
 		const result = this._iterator.next();
 		if (result.done) {
 			if (this._set.size > 0) {
 				this._iterator = this._set[Symbol.iterator]();
-				const value = /** @type {[T, V]} */ (this._iterator.next().value);
+				const value =
+					/** @type {[T, V, ...EXPECTED_ANY]} */
+					(this._iterator.next().value);
 				this._set.delete(...value);
 				return value;
 			}
 			return;
 		}
-		this._set.delete(.../** @type {[T, V]} */ (result.value));
+		this._set.delete(.../** @type {[T, V, ...EXPECTED_ANY]} */ (result.value));
 		return result.value;
 	}
 }

package/lib/util/TupleSet.js

@@ -6,14 +6,21 @@
 "use strict";
 
 /**
- * @template {any[]} T
+ * @template K
+ * @template V
+ * @typedef {Map<K, InnerMap<K, V> | Set<V>>} InnerMap
+ */
+
+/**
+ * @template T
+ * @template V
  */
 class TupleSet {
 	/**
-	 * @param {Iterable<T>=} init init
+	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} init init
 	 */
 	constructor(init) {
-		/** @type {Map<T, TODO>} */
+		/** @type {InnerMap<T, V>} */
 		this._map = new Map();
 		this.size = 0;
 		if (init) {
@@ -24,7 +31,7 @@ class TupleSet {
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
 	add(...args) {
@@ -35,12 +42,12 @@ class TupleSet {
 			if (innerMap === undefined) {
 				map.set(arg, (map = new Map()));
 			} else {
-				map = innerMap;
+				map = /** @type {InnerMap<T, V>} */ (innerMap);
 			}
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		let set = /** @type {Set<V>} */ (map.get(beforeLast));
 		if (set === undefined) {
 			map.set(beforeLast, (set = new Set()));
 		}
@@ -52,14 +59,14 @@ class TupleSet {
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
 			const arg = args[i];
-			map = map.get(arg);
+			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
 			if (map === undefined) {
 				return false;
 			}
@@ -76,14 +83,14 @@ class TupleSet {
 	}
 
 	/**
-	 * @param {T} args tuple
+	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
 			const arg = args[i];
-			map = map.get(arg);
+			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
 			if (map === undefined) {
 				return;
 			}
@@ -102,18 +109,20 @@ class TupleSet {
 	}
 
 	/**
-	 * @returns {Iterator<T>} iterator
+	 * @returns {Iterator<[T, V, ...EXPECTED_ANY]>} iterator
 	 */
 	[Symbol.iterator]() {
-		/** @type {TODO[]} */
+		// This is difficult to type because we can have a map inside a map inside a map, etc. where the end is a set (each key is an argument)
+		// But in basic use we only have 2 arguments in our methods, so we have `Map<K, Set<V>>`
+		/** @type {MapIterator<[T, InnerMap<T, V> | Set<V>]>[]} */
 		const iteratorStack = [];
-		/** @type {T[]} */
+		/** @type {[T?, V?, ...EXPECTED_ANY]} */
 		const tuple = [];
-		/** @type {Iterator<T> | undefined} */
+		/** @type {SetIterator<V> | undefined} */
 		let currentSetIterator;
 
 		/**
-		 * @param {TODO} it iterator
+		 * @param {MapIterator<[T, InnerMap<T, V> | Set<V>]>} it iterator
 		 * @returns {boolean} result
 		 */
 		const next = it => {
@@ -121,7 +130,10 @@ class TupleSet {
 			if (result.done) {
 				if (iteratorStack.length === 0) return false;
 				tuple.pop();
-				return next(iteratorStack.pop());
+				return next(
+					/** @type {MapIterator<[T, InnerMap<T, V> | Set<V>]>} */
+					(iteratorStack.pop())
+				);
 			}
 			const [key, value] = result.value;
 			iteratorStack.push(it);
@@ -141,13 +153,20 @@ class TupleSet {
 					const result = currentSetIterator.next();
 					if (result.done) {
 						tuple.pop();
-						if (!next(iteratorStack.pop())) {
+						if (
+							!next(
+								/** @type {MapIterator<[T, InnerMap<T, V> | Set<V>]>} */
+								(iteratorStack.pop())
+							)
+						) {
 							currentSetIterator = undefined;
 						}
 					} else {
 						return {
 							done: false,
-							value: /** @type {T} */ (tuple.concat(result.value))
+							value:
+								/** @type {[T, V, ...EXPECTED_ANY]} */
+								(tuple.concat(result.value))
 						};
 					}
 				}