webpack 5.111.1 → 5.112.1

package/lib/stats/StatsFactory.js

@@ -6,26 +6,32 @@
 "use strict";
 
 const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
-const smartGrouping = require("../util/smartGrouping");
+const smartGrouping = require("./smartGrouping");
 
-/** @import Chunk from "../Chunk" */
-/** @import { OriginRecord } from "../ChunkGroup" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import { OriginRecord } from "../graph/ChunkGroup" */
 /** @import Compilation, { Asset } from "../Compilation" */
-/** @import Dependency from "../Dependency" */
-/** @import Module from "../Module" */
-/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
-/** @typedef {import("../util/comparators").Comparator<EXPECTED_ANY>} Comparator */
-/** @import ModuleProfile from "../ModuleProfile" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraphConnection from "../graph/ModuleGraphConnection" */
+/** @import WebpackError from "../errors/WebpackError" */
+/**
+ * Defines the comparator type used by this module.
+ * @template T
+ * @typedef {import("../util/comparators").Comparator<T>} Comparator
+ */
+/** @import ModuleProfile from "../module/ModuleProfile" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * Defines the group config type used by this module.
  * @template T, R
- * @typedef {import("../util/smartGrouping").GroupConfig<T, R>} GroupConfig
+ * @typedef {import("./smartGrouping").GroupConfig<T, R>} GroupConfig
  */
 /**
  * @import {
  * 	ChunkGroupInfoWithName,
  * 	ModuleTrace,
+ * 	PreprocessedAsset,
  * 	StatsAsset,
  * 	StatsChunk,
  * 	StatsChunkGroup,
@@ -33,6 +39,7 @@ const smartGrouping = require("../util/smartGrouping");
  * 	StatsCompilation,
  * 	StatsError,
  * 	StatsModule,
+ * 	StatsModuleIssuer,
  * 	StatsModuleReason,
  * 	StatsModuleTraceDependency,
  * 	StatsModuleTraceItem,
@@ -72,25 +79,188 @@ const smartGrouping = require("../util/smartGrouping");
  * @typedef {T extends ChunkGroupInfoWithName[] ? Record<string, StatsObject<ChunkGroupInfoWithName, F>> : T extends (infer V)[] ? StatsObject<V, F>[] : StatsObject<T, F>} CreatedObject
  */
 
-/** @typedef {EXPECTED_ANY} ObjectForExtract */
-/** @typedef {EXPECTED_ANY} FactoryData */
-/** @typedef {EXPECTED_ANY} FactoryDataItem */
-/** @typedef {EXPECTED_ANY} Result */
+/**
+ * The `[object, data]` each `extract` key webpack registers receives.
+ * @typedef {object} KnownStatsFactoryExtract
+ * @property {[StatsCompilation, Compilation]} compilation
+ * @property {[StatsAsset, PreprocessedAsset]} asset
+ * @property {[StatsAsset, PreprocessedAsset]} asset$visible
+ * @property {[StatsChunkGroup, ChunkGroupInfoWithName]} chunkGroup
+ * @property {[StatsModule, Module]} module
+ * @property {[StatsModule, Module]} module$visible
+ * @property {[StatsModuleIssuer, Module]} moduleIssuer
+ * @property {[StatsProfile, ModuleProfile]} profile
+ * @property {[StatsModuleReason, ModuleGraphConnection]} moduleReason
+ * @property {[StatsChunk, Chunk]} chunk
+ * @property {[StatsChunkOrigin, OriginRecord]} chunkOrigin
+ * @property {[StatsError, WebpackError]} error
+ * @property {[StatsError, WebpackError]} warning
+ * @property {[StatsError, WebpackError]} cause
+ * @property {[StatsModuleTraceItem, ModuleTrace]} moduleTraceItem
+ * @property {[StatsModuleTraceDependency, Dependency]} moduleTraceDependency
+ */
+
+/**
+ * The `[item, created item]` of each array path webpack creates.
+ * @typedef {{
+ * "compilation.assets": [PreprocessedAsset, StatsAsset],
+ * "compilation.chunks": [Chunk, StatsChunk],
+ * "compilation.modules": [Module, StatsModule],
+ * "compilation.entrypoints": [ChunkGroupInfoWithName, StatsChunkGroup],
+ * "compilation.namedChunkGroups": [ChunkGroupInfoWithName, StatsChunkGroup],
+ * "compilation.errors": [Error, StatsError],
+ * "compilation.warnings": [Error, StatsError],
+ * "compilation.hints": [Error, StatsError],
+ * "compilation.children": [Compilation, StatsCompilation],
+ * "asset.related": [PreprocessedAsset, StatsAsset],
+ * "error.errors": [Error, StatsError],
+ * "warning.errors": [Error, StatsError],
+ * "chunk.modules": [Module, StatsModule],
+ * "chunk.rootModules": [Module, StatsModule],
+ * "chunk.origins": [OriginRecord, StatsChunkOrigin],
+ * "module.issuerPath": [Module, StatsModuleIssuer],
+ * "module.reasons": [ModuleGraphConnection, StatsModuleReason],
+ * "module.modules": [Module, StatsModule],
+ * "module.children": [Module, StatsModule],
+ * moduleTrace: [ModuleTrace, StatsModuleTraceItem],
+ * "moduleTraceItem.dependencies": [Dependency, StatsModuleTraceDependency],
+ * }} KnownStatsFactoryItems
+ */
+
+/** @typedef {{ [Key in keyof KnownStatsFactoryItems]: KnownStatsFactoryItems[Key][0] }} KnownStatsFactoryRawItems */
+/** @typedef {{ [Key in keyof KnownStatsFactoryItems]: KnownStatsFactoryItems[Key][1] }} KnownStatsFactoryResultItems */
+
+/**
+ * The item `getItemName` receives for each `<array path>[]` key webpack registers.
+ * @typedef {{
+ * "compilation.assets[]": PreprocessedAsset,
+ * "compilation.chunks[]": Chunk,
+ * "compilation.modules[]": Module,
+ * "compilation.entrypoints[]": ChunkGroupInfoWithName,
+ * "compilation.namedChunkGroups[]": ChunkGroupInfoWithName,
+ * "compilation.errors[]": Error,
+ * "compilation.warnings[]": Error,
+ * "compilation.hints[]": Error,
+ * "compilation.children[]": Compilation,
+ * "asset.related[]": PreprocessedAsset,
+ * "error.errors[]": Error,
+ * "warning.errors[]": Error,
+ * "chunk.modules[]": Module,
+ * "chunk.rootModules[]": Module,
+ * "chunk.origins[]": OriginRecord,
+ * "module.issuerPath[]": Module,
+ * "module.reasons[]": ModuleGraphConnection,
+ * "module.modules[]": Module,
+ * "module.children[]": Module,
+ * "moduleTrace[]": ModuleTrace,
+ * "moduleTraceItem.dependencies[]": Dependency,
+ * }} KnownStatsFactoryItemNames
+ */
+
+/**
+ * The data `getItemFactory` receives: an item name key gets that item's data.
+ * @typedef {{ [Key in keyof KnownStatsFactoryExtract]: KnownStatsFactoryExtract[Key][1] } & { "compilation.children[].compilation": Compilation }} KnownStatsFactoryItemFactories
+ */
+
+/**
+ * The value `result` passes on: an object key's stats object, an array path's (merged) items.
+ * @typedef {{ [Key in keyof KnownStatsFactoryExtract]: KnownStatsFactoryExtract[Key][0] } & { [Key in Exclude<keyof KnownStatsFactoryResultItems, "compilation.entrypoints" | "compilation.namedChunkGroups">]: KnownStatsFactoryResultItems[Key][] } & { "compilation.entrypoints": Record<string, StatsChunkGroup>, "compilation.namedChunkGroups": Record<string, StatsChunkGroup> }} KnownStatsFactoryResults
+ */
+
+/**
+ * `extract` hooks: the exact `[object, data]` for keys webpack registers, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryExtract>(key: K): SyncBailHook<[KnownStatsFactoryExtract[K][0], KnownStatsFactoryExtract[K][1], StatsFactoryContext], void>,
+ * for<O = EXPECTED_ANY, D = EXPECTED_ANY>(key: string): SyncBailHook<[O, D, StatsFactoryContext], void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, EXPECTED_ANY, StatsFactoryContext], void>>} StatsFactoryExtractHookMap
+ */
+
+/**
+ * Filter hooks over the raw item: exact for known array paths, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryRawItems>(key: K): SyncBailHook<[KnownStatsFactoryRawItems[K], StatsFactoryContext, number, number], boolean | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I, StatsFactoryContext, number, number], boolean | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsFactoryContext, number, number], boolean | void>>} StatsFactoryItemFilterHookMap
+ */
+
+/**
+ * Sort hooks over the raw item: exact for known array paths, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryRawItems>(key: K): SyncBailHook<[Comparator<KnownStatsFactoryRawItems[K]>[], StatsFactoryContext], void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[Comparator<I>[], StatsFactoryContext], void>
+ * } & HookMap<SyncBailHook<[Comparator<EXPECTED_ANY>[], StatsFactoryContext], void>>} StatsFactoryItemSortHookMap
+ */
+
+/**
+ * Filter hooks over the created item: exact for known array paths, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryResultItems>(key: K): SyncBailHook<[KnownStatsFactoryResultItems[K], StatsFactoryContext, number, number], boolean | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I, StatsFactoryContext, number, number], boolean | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsFactoryContext, number, number], boolean | void>>} StatsFactoryResultFilterHookMap
+ */
+
+/**
+ * Sort hooks over the created item: exact for known array paths, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryResultItems>(key: K): SyncBailHook<[Comparator<KnownStatsFactoryResultItems[K]>[], StatsFactoryContext], void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[Comparator<I>[], StatsFactoryContext], void>
+ * } & HookMap<SyncBailHook<[Comparator<EXPECTED_ANY>[], StatsFactoryContext], void>>} StatsFactoryResultSortHookMap
+ */
+
+/**
+ * `groupResults` hooks: group configs over the exact created item for known keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryResultItems, G = object>(key: K): SyncBailHook<[GroupConfig<KnownStatsFactoryResultItems[K], G>[], StatsFactoryContext], void>,
+ * for<I = EXPECTED_ANY, G = EXPECTED_ANY>(key: string): SyncBailHook<[GroupConfig<I, G>[], StatsFactoryContext], void>
+ * } & HookMap<SyncBailHook<[GroupConfig<EXPECTED_ANY, EXPECTED_ANY>[], StatsFactoryContext], void>>} StatsFactoryGroupResultsHookMap
+ */
+
+/**
+ * `merge` hooks: the exact created items for known keys, merged by default into an object by name.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryResultItems, R = Record<string, KnownStatsFactoryResultItems[K]>>(key: K): SyncBailHook<[KnownStatsFactoryResultItems[K][], StatsFactoryContext], R | void>,
+ * for<I = EXPECTED_ANY, R = EXPECTED_ANY>(key: string): SyncBailHook<[I[], StatsFactoryContext], R | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY[], StatsFactoryContext], EXPECTED_ANY>>} StatsFactoryMergeHookMap
+ */
+
+/**
+ * `result` hooks: the exact stats value for known keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryResults>(key: K): SyncBailHook<[KnownStatsFactoryResults[K], StatsFactoryContext], KnownStatsFactoryResults[K]>,
+ * for<R = EXPECTED_ANY>(key: string): SyncBailHook<[R, StatsFactoryContext], R>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsFactoryContext], EXPECTED_ANY>>} StatsFactoryResultHookMap
+ */
+
+/**
+ * `getItemName` hooks: the exact item for known `<array path>[]` keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryItemNames>(key: K): SyncBailHook<[KnownStatsFactoryItemNames[K], StatsFactoryContext], string | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I, StatsFactoryContext], string | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsFactoryContext], string | void>>} StatsFactoryGetItemNameHookMap
+ */
+
+/**
+ * `getItemFactory` hooks: the exact data for known item keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsFactoryItemFactories>(key: K): SyncBailHook<[KnownStatsFactoryItemFactories[K], StatsFactoryContext], StatsFactory | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I, StatsFactoryContext], StatsFactory | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsFactoryContext], StatsFactory | void>>} StatsFactoryGetItemFactoryHookMap
+ */
 
 /**
  * Defines the stats factory hooks type used by this module.
  * @typedef {object} StatsFactoryHooks
- * @property {HookMap<SyncBailHook<[ObjectForExtract, FactoryData, StatsFactoryContext], void>>} extract
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filter
- * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], void>>} sort
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filterSorted
- * @property {HookMap<SyncBailHook<[GroupConfig<EXPECTED_ANY, EXPECTED_ANY>[], StatsFactoryContext], void>>} groupResults
- * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], void>>} sortResults
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filterResults
- * @property {HookMap<SyncBailHook<[FactoryDataItem[], StatsFactoryContext], Result | void>>} merge
- * @property {HookMap<SyncBailHook<[Result, StatsFactoryContext], Result>>} result
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], string | void>>} getItemName
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], StatsFactory | void>>} getItemFactory
+ * @property {StatsFactoryExtractHookMap} extract
+ * @property {StatsFactoryItemFilterHookMap} filter
+ * @property {StatsFactoryItemSortHookMap} sort
+ * @property {StatsFactoryItemFilterHookMap} filterSorted
+ * @property {StatsFactoryGroupResultsHookMap} groupResults
+ * @property {StatsFactoryResultSortHookMap} sortResults
+ * @property {StatsFactoryResultFilterHookMap} filterResults
+ * @property {StatsFactoryMergeHookMap} merge
+ * @property {StatsFactoryResultHookMap} result
+ * @property {StatsFactoryGetItemNameHookMap} getItemName
+ * @property {StatsFactoryGetItemFactoryHookMap} getItemFactory
  */
 
 /**
@@ -178,7 +348,7 @@ class StatsFactory {
 	 */
 	_forEachLevel(hookMap, cache, type, fn) {
 		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			const result = fn(/** @type {H} */ (hook));
+			const result = fn(hook);
 			if (result !== undefined) return result;
 		}
 	}
@@ -187,7 +357,7 @@ class StatsFactory {
 	 * For each level waterfall.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template [D=EXPECTED_ANY]
+	 * @template D
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
@@ -198,7 +368,7 @@ class StatsFactory {
 	 */
 	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
 		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			data = fn(/** @type {H} */ (hook), data);
+			data = fn(hook, data);
 		}
 		return data;
 	}
@@ -207,7 +377,7 @@ class StatsFactory {
 	 * For each level filter.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} T
 	 * @template {T extends HookMap<infer H> ? H : never} H
-	 * @template [D=EXPECTED_ANY]
+	 * @template D
 	 * @param {T} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
@@ -223,7 +393,7 @@ class StatsFactory {
 		let i = 0;
 		return items.filter((item, idx) => {
 			for (const hook of hooks) {
-				const r = fn(/** @type {H} */ (hook), item, idx, i);
+				const r = fn(hook, item, idx, i);
 				if (r !== undefined) {
 					if (r) i++;
 					return r;
@@ -286,7 +456,7 @@ class StatsFactory {
 			);
 
 			// sort items
-			/** @type {Comparator[]} */
+			/** @type {Comparator<FactoryData extends (infer I)[] ? I : never>[]} */
 			const comparators = [];
 			this._forEachLevel(this.hooks.sort, this._caches.sort, type, (h) =>
 				h.call(comparators, context)
@@ -344,7 +514,7 @@ class StatsFactory {
 			});
 
 			// sort result items
-			/** @type {Comparator[]} */
+			/** @type {Comparator<(typeof resultItems)[number]>[]} */
 			const comparators2 = [];
 			this._forEachLevel(
 				this.hooks.sortResults,
@@ -357,7 +527,7 @@ class StatsFactory {
 			}
 
 			// group result items
-			/** @type {GroupConfig<EXPECTED_ANY, EXPECTED_ANY>[]} */
+			/** @type {GroupConfig<(typeof resultItems)[number], (typeof resultItems)[number]>[]} */
 			const groupConfigs = [];
 			this._forEachLevel(
 				this.hooks.groupResults,
@@ -397,8 +567,8 @@ class StatsFactory {
 				(h, r) => h.call(r, context)
 			);
 		}
-		/** @type {ObjectForExtract} */
-		const object = {};
+		const object =
+			/** @type {CreatedObject<FactoryData, FallbackCreatedObject>} */ ({});
 
 		// run extract on value
 		this._forEachLevel(this.hooks.extract, this._caches.extract, type, (h) =>
@@ -421,13 +591,14 @@ class StatsFactory {
  * for equal items. Inlined instead of `concatComparators(...c, keepOriginalOrder())`
  * because that combination is single-use per sort and only thrashes the comparator
  * caches (a fresh tiebreaker closure every call allocates a new cache entry).
- * @param {EXPECTED_ANY[]} items items to sort in place
- * @param {Comparator[]} comparators comparators applied in order
+ * @template T
+ * @param {T[]} items items to sort in place
+ * @param {import("../util/comparators").Comparator<T>[]} comparators comparators applied in order
  * @returns {void}
  */
 const sortWithOriginalOrder = (items, comparators) => {
 	// original-index tiebreaker keeps the sort stable on engines without a stable Array.sort
-	/** @type {Map<EXPECTED_ANY, number>} */
+	/** @type {Map<T, number>} */
 	const originalOrder = new Map();
 	for (let i = 0; i < items.length; i++) {
 		originalOrder.set(items[i], i);

package/lib/stats/StatsPrinter.js

@@ -12,9 +12,12 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
  * 	StatsAsset,
  * 	StatsChunk,
  * 	StatsChunkGroup,
+ * 	StatsChunkOrigin,
  * 	StatsCompilation,
  * 	StatsError,
+ * 	StatsJsonValue,
  * 	StatsLogging,
+ * 	StatsLoggingEntry,
  * 	StatsModule,
  * 	StatsModuleIssuer,
  * 	StatsModuleReason,
@@ -85,17 +88,117 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 
 /** @typedef {KnownStatsPrinterColorFunctions & KnownStatsPrinterFormatters & KnownStatsPrinterContext & Record<string, EXPECTED_ANY>} StatsPrinterContext */
 /** @typedef {StatsPrinterContext & Required<KnownStatsPrinterColorFunctions> & Required<KnownStatsPrinterFormatters> & { type: string }} StatsPrinterContextWithExtra */
-/** @typedef {EXPECTED_ANY} PrintObject */
+/**
+ * The value `print` receives for each object key webpack prints; the key also matches same-named fields.
+ * @typedef {object} KnownStatsPrintObjects
+ * @property {StatsCompilation} compilation
+ * @property {StatsAsset} asset
+ * @property {StatsChunk} chunk
+ * @property {StatsChunkGroup} chunkGroup
+ * @property {StatsModule | string | null} module
+ * @property {StatsModuleReason} moduleReason
+ * @property {StatsModuleIssuer} moduleIssuer
+ * @property {StatsChunkOrigin} chunkOrigin
+ * @property {StatsError} error
+ * @property {StatsProfile} profile
+ * @property {StatsLogging & { name: string }} loggingGroup
+ * @property {StatsModuleTraceItem} moduleTraceItem
+ * @property {StatsModuleTraceDependency} moduleTraceDependency
+ */
+
+/**
+ * The item of each array path webpack prints stats objects for.
+ * @typedef {{
+ * "compilation.assets": StatsAsset,
+ * "compilation.modules": StatsModule,
+ * "compilation.chunks": StatsChunk,
+ * "compilation.entrypoints": StatsChunkGroup,
+ * "compilation.namedChunkGroups": StatsChunkGroup,
+ * "compilation.errors": StatsError,
+ * "compilation.warnings": StatsError,
+ * "compilation.hints": StatsError,
+ * "compilation.logging": StatsLogging & { name: string },
+ * "compilation.children": StatsCompilation,
+ * "asset.related": StatsAsset,
+ * "asset.children": StatsAsset,
+ * "module.modules": StatsModule,
+ * "module.children": StatsModule,
+ * "module.reasons": StatsModuleReason,
+ * "moduleReason.children": StatsModuleReason,
+ * "module.issuerPath": StatsModuleIssuer,
+ * "chunk.origins": StatsChunkOrigin,
+ * "chunk.modules": StatsModule,
+ * "loggingGroup.entries": StatsLoggingEntry,
+ * "loggingEntry.children": StatsLoggingEntry,
+ * "error.moduleTrace": StatsModuleTraceItem,
+ * "error.errors": StatsError,
+ * "moduleTraceItem.dependencies": StatsModuleTraceDependency,
+ * }} KnownStatsPrintItems
+ */
+
+/**
+ * The item `getItemName` receives for each `<array path>[]` key of `KnownStatsPrintItems`.
+ * @typedef {{
+ * "compilation.assets[]": StatsAsset,
+ * "compilation.modules[]": StatsModule,
+ * "compilation.chunks[]": StatsChunk,
+ * "compilation.entrypoints[]": StatsChunkGroup,
+ * "compilation.namedChunkGroups[]": StatsChunkGroup,
+ * "compilation.errors[]": StatsError,
+ * "compilation.warnings[]": StatsError,
+ * "compilation.hints[]": StatsError,
+ * "compilation.logging[]": StatsLogging & { name: string },
+ * "compilation.children[]": StatsCompilation,
+ * "asset.related[]": StatsAsset,
+ * "asset.children[]": StatsAsset,
+ * "module.modules[]": StatsModule,
+ * "module.children[]": StatsModule,
+ * "module.reasons[]": StatsModuleReason,
+ * "moduleReason.children[]": StatsModuleReason,
+ * "module.issuerPath[]": StatsModuleIssuer,
+ * "chunk.origins[]": StatsChunkOrigin,
+ * "chunk.modules[]": StatsModule,
+ * "loggingGroup.entries[]": StatsLoggingEntry,
+ * "loggingEntry.children[]": StatsLoggingEntry,
+ * "error.moduleTrace[]": StatsModuleTraceItem,
+ * "error.errors[]": StatsError,
+ * "moduleTraceItem.dependencies[]": StatsModuleTraceDependency,
+ * }} KnownStatsPrintItemNames
+ */
+
+/**
+ * `sortItems` hooks: the exact items for known array paths, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsPrintItems>(key: K): SyncBailHook<[KnownStatsPrintItems[K][], StatsPrinterContext], boolean | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I[], StatsPrinterContext], boolean | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY[], StatsPrinterContext], boolean | void>>} StatsPrinterSortItemsHookMap
+ */
+
+/**
+ * `getItemName` hooks: the exact item for known `<array path>[]` keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsPrintItemNames>(key: K): SyncBailHook<[KnownStatsPrintItemNames[K], StatsPrinterContext], string | void>,
+ * for<I = EXPECTED_ANY>(key: string): SyncBailHook<[I, StatsPrinterContext], string | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsPrinterContext], string | void>>} StatsPrinterGetItemNameHookMap
+ */
+
+/**
+ * `print` hooks: the exact value for known object keys, generic for plugin keys.
+ * @typedef {{
+ * for<K extends keyof KnownStatsPrintObjects>(key: K): SyncBailHook<[KnownStatsPrintObjects[K], StatsPrinterContext], string | undefined | void>,
+ * for<T = EXPECTED_ANY>(key: string): SyncBailHook<[T, StatsPrinterContext], string | undefined | void>
+ * } & HookMap<SyncBailHook<[EXPECTED_ANY, StatsPrinterContext], string | undefined | void>>} StatsPrinterPrintHookMap
+ */
 
 /**
  * Represents the stats printer runtime component.
  * @typedef {object} StatsPrintHooks
  * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>} sortElements
  * @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 {StatsPrinterSortItemsHookMap} sortItems
+ * @property {StatsPrinterGetItemNameHookMap} getItemName
  * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], string | undefined>>} printItems
- * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | undefined | void>>} print
+ * @property {StatsPrinterPrintHookMap} print
  * @property {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} result
  */
 
@@ -193,8 +296,9 @@ class StatsPrinter {
 
 	/**
 	 * Returns printed result.
+	 * @template T
 	 * @param {string} type The type
-	 * @param {PrintObject} object Object to print
+	 * @param {T} object Object to print
 	 * @param {StatsPrinterContext=} baseContext The base context
 	 * @returns {string | undefined} printed result
 	 */
@@ -214,8 +318,9 @@ class StatsPrinter {
 	/**
 	 * Returns printed result.
 	 * @private
+	 * @template T
 	 * @param {string} type type
-	 * @param {PrintObject} object object
+	 * @param {T} object object
 	 * @param {StatsPrinterContext=} baseContext context
 	 * @returns {string | undefined} printed result
 	 */
@@ -273,7 +378,9 @@ class StatsPrinter {
 				}
 			} else if (object !== null && typeof object === "object") {
 				const elements = Object.keys(object).filter(
-					(key) => object[key] !== undefined
+					(key) =>
+						/** @type {Record<string, StatsJsonValue>} */ (object)[key] !==
+						undefined
 				);
 				this._forEachLevel(this.hooks.sortElements, type, (h) =>
 					h.call(
@@ -283,12 +390,18 @@ class StatsPrinter {
 					)
 				);
 				const printedElements = elements.map((element) => {
-					const content = this.print(`${type}.${element}`, object[element], {
-						...context,
-						_parent: object,
-						_element: element,
-						[element]: object[element]
-					});
+					const content = this.print(
+						`${type}.${element}`,
+						/** @type {Record<string, StatsJsonValue>} */ (object)[element],
+						{
+							...context,
+							_parent: object,
+							_element: element,
+							[element]: /** @type {Record<string, StatsJsonValue>} */ (object)[
+								element
+							]
+						}
+					);
 					return { element, content };
 				});
 				printResult = this._forEachLevel(this.hooks.printElements, type, (h) =>

package/lib/{ChunkTemplate.js → template/ChunkTemplate.js}

@@ -6,28 +6,28 @@
 "use strict";
 
 const util = require("util");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 
 /** @import { Tap } from "tapable" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import Chunk from "./Chunk" */
-/** @import Compilation, { ChunkHashContext } from "./Compilation" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import Compilation, { ChunkHashContext } from "../Compilation" */
 /** @import ModuleTemplate from "./ModuleTemplate" */
-/** @import { RenderContext } from "./javascript/JavascriptModulesPlugin" */
+/** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
 /** @import { RenderManifestEntry, RenderManifestOptions } from "./Template" */
-/** @import Hash from "./util/Hash" */
+/** @import Hash from "../util/Hash" */
 /**
  * Defines the if set type used by this module.
  * @template T
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
 
-// TODO webpack 6 remove this class
+// TODO in the next major release: remove this class
 class ChunkTemplate {
 	/**
 	 * Creates an instance of ChunkTemplate.

package/lib/{ConditionalInitFragment.js → template/ConditionalInitFragment.js}

@@ -6,13 +6,13 @@
 "use strict";
 
 const { ConcatSource, PrefixSource } = require("webpack-sources");
+const { mergeRuntime } = require("../util/runtime");
 const InitFragment = require("./InitFragment");
 const Template = require("./Template");
-const { mergeRuntime } = require("./util/runtime");
 
 /** @import { Source } from "webpack-sources" */
-/** @import { GenerateContext } from "./Generator" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import { GenerateContext } from "../module/Generator" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Returns wrapped source.