@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -15,6 +15,7 @@ const SizeLimitsPlugin = require("../performance/SizeLimitsPlugin");
 const { countIterable } = require("../util/IterableHelpers");
 const {
 	compareChunksById,
+	compareErrors,
 	compareIds,
 	compareLocations,
 	compareModulesByIdentifier,
@@ -25,34 +26,39 @@ const {
 const formatLocation = require("../util/formatLocation");
 const { makePathsRelative, parseResource } = require("../util/identifier");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").StatsValue} StatsValue */
-/** @typedef {import("./StatsFactory")} StatsFactory */
-/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../Chunk").ChunkName} ChunkName */
-/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").Asset} Asset */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").ExcludeModulesType} ExcludeModulesType */
-/** @typedef {import("../Compilation").KnownNormalizedStatsOptions} KnownNormalizedStatsOptions */
-/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").NameForCondition} NameForCondition */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleProfile")} ModuleProfile */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../serialization/AggregateErrorSerializer").AggregateError} AggregateError */
-/** @typedef {import("../serialization/ErrorObjectSerializer").ErrorWithCause} ErrorWithCause */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
+/** @import { Source } from "webpack-sources" */
+/** @import { StatsValue } from "../../declarations/WebpackOptions" */
+/** @import StatsFactory, { StatsFactoryContext } from "./StatsFactory" */
+/** @import Chunk, { ChunkId, ChunkName } from "../Chunk" */
+/** @import { ModuleId } from "../ChunkGraph" */
+/** @import ChunkGroup, { OriginRecord } from "../ChunkGroup" */
+/**
+ * @import Compilation, {
+ * 	Asset,
+ * 	AssetInfo,
+ * 	ExcludeModulesType,
+ * 	KnownNormalizedStatsOptions,
+ * 	NormalizedStatsOptions
+ * } from "../Compilation"
+ */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import Dependency, {
+ * 	DependencyLocation,
+ * 	ExportInfoName
+ * } from "../Dependency"
+ */
+/** @import Module, { NameForCondition, BuildInfo } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import ModuleProfile from "../ModuleProfile" */
+/** @import WebpackError from "../errors/WebpackError" */
+/**
+ * @import {
+ * 	AggregateError
+ * } from "../serialization/AggregateErrorSerializer"
+ */
+/** @import { ErrorWithCause } from "../serialization/ErrorObjectSerializer" */
 
 /**
  * Defines the shared type used by this module.
@@ -91,6 +97,8 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number=} errorsCount
  * @property {StatsError[]=} warnings
  * @property {number=} warningsCount
+ * @property {StatsError[]=} hints
+ * @property {number=} hintsCount
  * @property {StatsCompilation[]=} children
  * @property {Record<string, StatsLogging>=} logging
  * @property {number=} filteredWarningDetailsCount
@@ -834,22 +842,24 @@ const SIMPLE_EXTRACTORS = {
 			}
 
 			object.assetsByChunkName = {};
-			for (const [file, chunks] of [
-				...compilationFileToChunks,
-				...compilationAuxiliaryFileToChunks
+			for (const fileToChunks of [
+				compilationFileToChunks,
+				compilationAuxiliaryFileToChunks
 			]) {
-				for (const chunk of chunks) {
-					const name = chunk.name;
-					if (!name) continue;
-					if (
-						!Object.prototype.hasOwnProperty.call(
-							object.assetsByChunkName,
-							name
-						)
-					) {
-						object.assetsByChunkName[name] = [];
+				for (const [file, chunks] of fileToChunks) {
+					for (const chunk of chunks) {
+						const name = chunk.name;
+						if (!name) continue;
+						if (
+							!Object.prototype.hasOwnProperty.call(
+								object.assetsByChunkName,
+								name
+							)
+						) {
+							object.assetsByChunkName[name] = [];
+						}
+						object.assetsByChunkName[name].push(file);
 					}
-					object.assetsByChunkName[name].push(file);
 				}
 			}
 
@@ -1038,6 +1048,19 @@ const SIMPLE_EXTRACTORS = {
 					);
 			});
 		},
+		hints: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			// Sorted here rather than in `sortItemsWithChunkIds`, which runs before
+			// the `afterSeal` and `afterEmit` producers have appended their hints.
+			object.hints = factory.create(
+				`${type}.hints`,
+				[...compilation.hints].sort(compareErrors),
+				context
+			);
+		},
+		hintsCount: (object, compilation) => {
+			object.hintsCount = countWithChildren(compilation, (c) => c.hints);
+		},
 		children: (object, compilation, context, options, factory) => {
 			const { type } = context;
 			object.children = factory.create(
@@ -1279,19 +1302,16 @@ const SIMPLE_EXTRACTORS = {
 			for (const sourceType of module.getSourceTypes()) {
 				sizes[sourceType] = module.size(sourceType);
 			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				type: "module",
-				moduleType: module.type,
-				layer: module.layer,
-				size: module.size(),
-				sizes,
-				built,
-				codeGenerated,
-				buildTimeExecuted,
-				cached: !built && !codeGenerated
-			};
-			Object.assign(object, statsModule);
+			// assign fields directly to avoid an intermediate object + copy per module
+			object.type = "module";
+			object.moduleType = module.type;
+			object.layer = module.layer;
+			object.size = module.size();
+			object.sizes = sizes;
+			object.built = built;
+			object.codeGenerated = codeGenerated;
+			object.buildTimeExecuted = buildTimeExecuted;
+			object.cached = !built && !codeGenerated;
 			if (built || codeGenerated || options.cachedModules) {
 				Object.assign(
 					object,
@@ -1323,42 +1343,40 @@ const SIMPLE_EXTRACTORS = {
 			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
 				module.buildInfo
 			);
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener),
-				nameForCondition: module.nameForCondition(),
-				index: /** @type {number} */ (moduleGraph.getPreOrderIndex(module)),
-				preOrderIndex: /** @type {number} */ (
-					moduleGraph.getPreOrderIndex(module)
-				),
-				index2: /** @type {number} */ (moduleGraph.getPostOrderIndex(module)),
-				postOrderIndex: /** @type {number} */ (
-					moduleGraph.getPostOrderIndex(module)
-				),
-				cacheable,
-				notCacheableReasons:
-					notCacheableReasons &&
-					notCacheableReasons.map(
-						(request) =>
-							/** @type {string} */ (requestShortener.shorten(request))
-					),
-				optional: module.isOptional(moduleGraph),
-				orphan:
-					!type.endsWith("module.modules[].module$visible") &&
-					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
-				dependent: rootModules ? !rootModules.has(module) : undefined,
-				issuer: issuer && issuer.identifier(),
-				issuerName: issuer && issuer.readableIdentifier(requestShortener),
-				issuerPath:
-					issuer &&
-					/** @type {StatsModuleIssuer[] | undefined} */
-					(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context)),
-				failed: errorsCount > 0,
-				errors: errorsCount,
-				warnings: warningsCount
-			};
-			Object.assign(object, statsModule);
+			const preOrderIndex = /** @type {number} */ (
+				moduleGraph.getPreOrderIndex(module)
+			);
+			const postOrderIndex = /** @type {number} */ (
+				moduleGraph.getPostOrderIndex(module)
+			);
+			// assign fields directly to avoid an intermediate object + copy per module
+			object.identifier = module.identifier();
+			object.name = module.readableIdentifier(requestShortener);
+			object.nameForCondition = module.nameForCondition();
+			object.index = preOrderIndex;
+			object.preOrderIndex = preOrderIndex;
+			object.index2 = postOrderIndex;
+			object.postOrderIndex = postOrderIndex;
+			object.cacheable = cacheable;
+			object.notCacheableReasons =
+				notCacheableReasons &&
+				notCacheableReasons.map(
+					(request) => /** @type {string} */ (requestShortener.shorten(request))
+				);
+			object.optional = module.isOptional(moduleGraph);
+			object.orphan =
+				!type.endsWith("module.modules[].module$visible") &&
+				compilation.chunkGraph.getNumberOfModuleChunks(module) === 0;
+			object.dependent = rootModules ? !rootModules.has(module) : undefined;
+			object.issuer = issuer && issuer.identifier();
+			object.issuerName = issuer && issuer.readableIdentifier(requestShortener);
+			object.issuerPath =
+				issuer &&
+				/** @type {StatsModuleIssuer[] | undefined} */
+				(factory.create(`${type.slice(0, -8)}.issuerPath`, path, context));
+			object.failed = errorsCount > 0;
+			object.errors = errorsCount;
+			object.warnings = warningsCount;
 			if (profile) {
 				object.profile = factory.create(
 					`${type.slice(0, -8)}.profile`,
@@ -1470,27 +1488,24 @@ const SIMPLE_EXTRACTORS = {
 	},
 	profile: {
 		_: (object, profile) => {
-			/** @type {KnownStatsProfile} */
-			const statsProfile = {
-				total:
-					profile.factory +
-					profile.restoring +
-					profile.integration +
-					profile.building +
-					profile.storing,
-				resolving: profile.factory,
-				restoring: profile.restoring,
-				building: profile.building,
-				integration: profile.integration,
-				storing: profile.storing,
-				additionalResolving: profile.additionalFactories,
-				additionalIntegration: profile.additionalIntegration,
-				// TODO remove this in webpack 6
-				factory: profile.factory,
-				// TODO remove this in webpack 6
-				dependencies: profile.additionalFactories
-			};
-			Object.assign(object, statsProfile);
+			// assign fields directly to avoid an intermediate object + copy
+			object.total =
+				profile.factory +
+				profile.restoring +
+				profile.integration +
+				profile.building +
+				profile.storing;
+			object.resolving = profile.factory;
+			object.restoring = profile.restoring;
+			object.building = profile.building;
+			object.integration = profile.integration;
+			object.storing = profile.storing;
+			object.additionalResolving = profile.additionalFactories;
+			object.additionalIntegration = profile.additionalIntegration;
+			// TODO remove this in webpack 6
+			object.factory = profile.factory;
+			// TODO remove this in webpack 6
+			object.dependencies = profile.additionalFactories;
 		}
 	},
 	moduleIssuer: {
@@ -1499,12 +1514,9 @@ const SIMPLE_EXTRACTORS = {
 			const compilation = /** @type {Compilation} */ (context.compilation);
 			const { moduleGraph } = compilation;
 			const profile = moduleGraph.getProfile(module);
-			/** @type {Partial<KnownStatsModuleIssuer>} */
-			const statsModuleIssuer = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener)
-			};
-			Object.assign(object, statsModuleIssuer);
+			// assign fields directly to avoid an intermediate object + copy per issuer
+			object.identifier = module.identifier();
+			object.name = module.readableIdentifier(requestShortener);
 			if (profile) {
 				object.profile = factory.create(`${type}.profile`, profile, context);
 			}
@@ -1518,31 +1530,26 @@ const SIMPLE_EXTRACTORS = {
 			const dep = reason.dependency;
 			const moduleDep =
 				dep && dep instanceof ModuleDependency ? dep : undefined;
-			/** @type {KnownStatsModuleReason} */
-			const statsModuleReason = {
-				moduleIdentifier: reason.originModule
-					? reason.originModule.identifier()
-					: null,
-				module: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				moduleName: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				resolvedModuleIdentifier: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.identifier()
-					: null,
-				resolvedModule: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
-					: null,
-				type: reason.dependency ? reason.dependency.type : null,
-				active: reason.isActive(runtime),
-				explanation: reason.explanation,
-				userRequest: (moduleDep && moduleDep.userRequest) || null
-			};
-			Object.assign(object, statsModuleReason);
-			if (reason.dependency) {
-				const locInfo = formatLocation(reason.dependency.loc);
+			const { originModule, resolvedOriginModule } = reason;
+			const originName = originModule
+				? originModule.readableIdentifier(requestShortener)
+				: null;
+			// assign fields directly to avoid an intermediate object + copy per reason
+			object.moduleIdentifier = originModule ? originModule.identifier() : null;
+			object.module = originName;
+			object.moduleName = originName;
+			object.resolvedModuleIdentifier = resolvedOriginModule
+				? resolvedOriginModule.identifier()
+				: null;
+			object.resolvedModule = resolvedOriginModule
+				? resolvedOriginModule.readableIdentifier(requestShortener)
+				: null;
+			object.type = dep ? dep.type : null;
+			object.active = reason.isActive(runtime);
+			object.explanation = reason.explanation;
+			object.userRequest = (moduleDep && moduleDep.userRequest) || null;
+			if (dep) {
+				const locInfo = formatLocation(dep.loc);
 				if (locInfo) {
 					object.loc = locInfo;
 				}
@@ -1561,29 +1568,26 @@ const SIMPLE_EXTRACTORS = {
 		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
 			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
 
-			/** @type {KnownStatsChunk} */
-			const statsChunk = {
-				rendered: chunk.rendered,
-				initial: chunk.canBeInitial(),
-				entry: chunk.hasRuntime(),
-				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
-				reason: chunk.chunkReason,
-				size: chunkGraph.getChunkModulesSize(chunk),
-				sizes: chunkGraph.getChunkModulesSizes(chunk),
-				names: chunk.name ? [chunk.name] : [],
-				idHints: [...chunk.idNameHints],
-				runtime:
-					chunk.runtime === undefined
-						? undefined
-						: typeof chunk.runtime === "string"
-							? [makePathsRelative(chunk.runtime)]
-							: Array.from(chunk.runtime.sort(), makePathsRelative),
-				files: [...chunk.files],
-				auxiliaryFiles: [...chunk.auxiliaryFiles].sort(compareIds),
-				hash: /** @type {string} */ (chunk.renderedHash),
-				childrenByOrder: childIdByOrder
-			};
-			Object.assign(object, statsChunk);
+			// assign fields directly to avoid an intermediate object + copy per chunk
+			object.rendered = chunk.rendered;
+			object.initial = chunk.canBeInitial();
+			object.entry = chunk.hasRuntime();
+			object.recorded = AggressiveSplittingPlugin.wasChunkRecorded(chunk);
+			object.reason = chunk.chunkReason;
+			object.size = chunkGraph.getChunkModulesSize(chunk);
+			object.sizes = chunkGraph.getChunkModulesSizes(chunk);
+			object.names = chunk.name ? [chunk.name] : [];
+			object.idHints = [...chunk.idNameHints];
+			object.runtime =
+				chunk.runtime === undefined
+					? undefined
+					: typeof chunk.runtime === "string"
+						? [makePathsRelative(chunk.runtime)]
+						: Array.from(chunk.runtime.sort(), makePathsRelative);
+			object.files = [...chunk.files];
+			object.auxiliaryFiles = [...chunk.auxiliaryFiles].sort(compareIds);
+			object.hash = /** @type {string} */ (chunk.renderedHash);
+			object.childrenByOrder = childIdByOrder;
 		},
 		ids: (object, chunk) => {
 			object.id = /** @type {ChunkId} */ (chunk.id);
@@ -1660,17 +1664,16 @@ const SIMPLE_EXTRACTORS = {
 	},
 	chunkOrigin: {
 		_: (object, origin, context, { requestShortener }) => {
-			/** @type {KnownStatsChunkOrigin} */
-			const statsChunkOrigin = {
-				module: origin.module ? origin.module.identifier() : "",
-				moduleIdentifier: origin.module ? origin.module.identifier() : "",
-				moduleName: origin.module
-					? origin.module.readableIdentifier(requestShortener)
-					: "",
-				loc: formatLocation(origin.loc),
-				request: origin.request
-			};
-			Object.assign(object, statsChunkOrigin);
+			const originModule = origin.module;
+			const identifier = originModule ? originModule.identifier() : "";
+			// assign fields directly to avoid an intermediate object + copy per origin
+			object.module = identifier;
+			object.moduleIdentifier = identifier;
+			object.moduleName = originModule
+				? originModule.readableIdentifier(requestShortener)
+				: "";
+			object.loc = formatLocation(origin.loc);
+			object.request = origin.request;
 		},
 		ids: (object, origin, { compilation: { chunkGraph } }) => {
 			object.moduleId = origin.module
@@ -1691,13 +1694,16 @@ const SIMPLE_EXTRACTORS = {
 			object.originName = origin.readableIdentifier(requestShortener);
 			object.moduleIdentifier = module.identifier();
 			object.moduleName = module.readableIdentifier(requestShortener);
-			const dependencies = [...moduleGraph.getIncomingConnections(module)]
-				.filter((c) => c.resolvedOriginModule === origin && c.dependency)
-				.map((c) => c.dependency);
+			/** @type {Set<Dependency>} */
+			const dependencies = new Set();
+			for (const c of moduleGraph.getIncomingConnections(module)) {
+				if (c.resolvedOriginModule === origin && c.dependency) {
+					dependencies.add(c.dependency);
+				}
+			}
 			object.dependencies = factory.create(
 				`${type}.dependencies`,
-				/** @type {Dependency[]} */
-				([...new Set(dependencies)]),
+				[...dependencies],
 				context
 			);
 		},
@@ -1749,17 +1755,50 @@ const FILTER_RESULTS = {
 	}
 };
 
+// module sort selectors close over moduleGraph, so cache the built comparators per
+// moduleGraph (stable per compilation) instead of rebuilding them on every sort
+/** @type {WeakMap<ModuleGraph, Comparator<Module>[]>} */
+const modulesSorterCache = new WeakMap();
+
 /** @type {Record<string, (comparators: Comparator<Module>[], context: StatsFactoryContext) => void>} */
 const MODULES_SORTER = {
 	_: (comparators, { compilation: { moduleGraph } }) => {
-		comparators.push(
-			compareSelect((m) => moduleGraph.getDepth(m), compareNumbers),
-			compareSelect((m) => moduleGraph.getPreOrderIndex(m), compareNumbers),
-			compareSelect((m) => m.identifier(), compareIds)
-		);
+		let cached = modulesSorterCache.get(moduleGraph);
+		if (cached === undefined) {
+			cached = [
+				compareSelect((m) => moduleGraph.getDepth(m), compareNumbers),
+				compareSelect((m) => moduleGraph.getPreOrderIndex(m), compareNumbers),
+				compareSelect((m) => m.identifier(), compareIds)
+			];
+			modulesSorterCache.set(moduleGraph, cached);
+		}
+		comparators.push(...cached);
 	}
 };
 
+// reason comparators use only pure selectors, so build them once instead of per
+// module.reasons sort (which runs once per module and otherwise thrashes the caches)
+/** @type {Comparator<ModuleGraphConnection>[]} */
+const MODULE_REASONS_COMPARATORS = [
+	compareSelect((x) => x.originModule, compareModulesByIdentifier),
+	compareSelect((x) => x.resolvedOriginModule, compareModulesByIdentifier),
+	compareSelect(
+		(x) => x.dependency,
+		concatComparators(
+			compareSelect(
+				/**
+				 * Handles the callback for this hook.
+				 * @param {Dependency} x dependency
+				 * @returns {DependencyLocation} location
+				 */
+				(x) => x.loc,
+				compareLocations
+			),
+			compareSelect((x) => x.type, compareIds)
+		)
+	)
+];
+
 /**
  * @type {{
  * "compilation.chunks": Record<string, (comparators: Comparator<Chunk>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>,
@@ -1782,30 +1821,8 @@ const SORTERS = {
 	"chunk.modules": MODULES_SORTER,
 	"module.modules": MODULES_SORTER,
 	"module.reasons": {
-		_: (comparators, _context) => {
-			comparators.push(
-				compareSelect((x) => x.originModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect((x) => x.resolvedOriginModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(
-					(x) => x.dependency,
-					concatComparators(
-						compareSelect(
-							/**
-							 * Handles the  callback for this hook.
-							 * @param {Dependency} x dependency
-							 * @returns {DependencyLocation} location
-							 */
-							(x) => x.loc,
-							compareLocations
-						),
-						compareSelect((x) => x.type, compareIds)
-					)
-				)
-			);
+		_: (comparators) => {
+			comparators.push(...MODULE_REASONS_COMPARATORS);
 		}
 	},
 	"chunk.origins": {
@@ -2588,6 +2605,17 @@ const sortOrderRegular = (field) => {
 	return true;
 };
 
+/**
+ * Returns zero.
+ * @param {EXPECTED_ANY} a first
+ * @param {EXPECTED_ANY} b second
+ * @returns {-1 | 0 | 1} zero
+ */
+const noSort = (a, b) => 0;
+
+/** @type {Map<string, (a: EXPECTED_ANY, b: EXPECTED_ANY) => 0 | 1 | -1>} */
+const sortByFieldCache = new Map();
+
 /**
  * Returns comparators.
  * @template T
@@ -2595,29 +2623,24 @@ const sortOrderRegular = (field) => {
  * @returns {(a: T, b: T) => 0 | 1 | -1} comparators
  */
 const sortByField = (field) => {
-	if (!field) {
-		/**
-		 * Returns zero.
-		 * @param {T} a first
-		 * @param {T} b second
-		 * @returns {-1 | 0 | 1} zero
-		 */
-		const noSort = (a, b) => 0;
-		return noSort;
-	}
+	if (!field) return noSort;
+
+	// memoize per field: the comparator (and its selector) is pure, so building it
+	// once keeps compareSelect's cache warm instead of allocating a new entry per sort
+	let sortFn = sortByFieldCache.get(field);
+	if (sortFn !== undefined) return sortFn;
 
 	const fieldKey = normalizeFieldKey(field);
 
-	let sortFn = compareSelect((m) => m[fieldKey], compareIds);
+	sortFn = compareSelect((m) => m[fieldKey], compareIds);
 
 	// if a field is prefixed with a "!" the sort is reversed!
-	const sortIsRegular = sortOrderRegular(field);
-
-	if (!sortIsRegular) {
+	if (!sortOrderRegular(field)) {
 		const oldSortFn = sortFn;
 		sortFn = (a, b) => oldSortFn(b, a);
 	}
 
+	sortByFieldCache.set(field, sortFn);
 	return sortFn;
 };
 
@@ -2629,13 +2652,16 @@ const sortByField = (field) => {
  * }} AssetSorters
  */
 
+/** @type {Comparator<Asset>} */
+const compareAssetsByName = compareSelect((asset) => asset.name, compareIds);
+
 /** @type {AssetSorters} */
 const ASSET_SORTERS = {
 	assetsSort: (comparators, context, { assetsSort }) => {
 		comparators.push(sortByField(assetsSort));
 	},
 	_: (comparators) => {
-		comparators.push(compareSelect((a) => a.name, compareIds));
+		comparators.push(compareAssetsByName);
 	}
 };
 
@@ -2719,6 +2745,7 @@ const ITEM_NAMES = {
 	"compilation.namedChunkGroups[]": "chunkGroup",
 	"compilation.errors[]": "error",
 	"compilation.warnings[]": "warning",
+	"compilation.hints[]": "warning",
 	"error.errors[]": "error",
 	"warning.errors[]": "error",
 	"chunk.modules[]": "module",