webpack 5.108.4 → 5.109.1

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -508,8 +508,18 @@ const MODULE_SIMPLE_PRINTERS = {
 	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
 	"module.depth": (depth, { formatFlag }) =>
 		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
-	"module.cacheable": (cacheable, { formatFlag, red }) =>
-		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
+	"module.cacheable": (cacheable, { formatFlag, red, module }) =>
+		cacheable === false
+			? red(
+					formatFlag(
+						module.notCacheableReasons && module.notCacheableReasons.length > 0
+							? `not cacheable: ${module.notCacheableReasons.join(", ")}`
+							: "not cacheable"
+					)
+				)
+			: undefined,
+	// rendered as part of the "module.cacheable" flag
+	"module.notCacheableReasons": () => undefined,
 	"module.orphan": (orphan, { formatFlag, yellow }) =>
 		orphan ? yellow(formatFlag("orphan")) : undefined,
 	// "module.runtime": (runtime, { formatFlag, yellow }) =>
@@ -1685,172 +1695,30 @@ class DefaultStatsPrinterPlugin {
 						context.timeReference = compilation.time;
 					});
 
-				for (const key of /** @type {(keyof CompilationSimplePrinters)[]} */ (
-					Object.keys(COMPILATION_SIMPLE_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<CompilationSimplePrinters[keyof CompilationSimplePrinters]>} */
-						(COMPILATION_SIMPLE_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"compilation">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof AssetSimplePrinters)[]} */ (
-					Object.keys(ASSET_SIMPLE_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<AssetSimplePrinters[keyof AssetSimplePrinters]>} */
-						(ASSET_SIMPLE_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"asset" | "asset.info">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleSimplePrinters)[]} */ (
-					Object.keys(MODULE_SIMPLE_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "module">} */
-						(MODULE_SIMPLE_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"module">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleIssuerPrinters)[]} */ (
-					Object.keys(MODULE_ISSUER_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<ModuleIssuerPrinters[keyof ModuleIssuerPrinters]>} */
-						(MODULE_ISSUER_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"moduleIssuer">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleReasonsPrinters)[]} */ (
-					Object.keys(MODULE_REASON_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "moduleReason">} */
-						(MODULE_REASON_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"moduleReason">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleProfilePrinters)[]} */ (
-					Object.keys(MODULE_PROFILE_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<ModuleProfilePrinters[keyof ModuleProfilePrinters]>} */
-						(MODULE_PROFILE_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"profile">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ChunkGroupPrinters)[]} */ (
-					Object.keys(CHUNK_GROUP_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "chunkGroupKind" | "chunkGroup">} */
-						(CHUNK_GROUP_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"chunkGroupKind" | "chunkGroup">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ChunkPrinters)[]} */ (
-					Object.keys(CHUNK_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "chunk">} */
-						(CHUNK_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"chunk">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ErrorPrinters)[]} */ (
-					Object.keys(ERROR_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "error">} */
-						(ERROR_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"error">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof LogEntryPrinters)[]} */ (
-					Object.keys(LOG_ENTRY_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {SimplePrinter<EXPECTED_ANY, "logging">} */
-						(LOG_ENTRY_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"logging">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleTraceDependencyPrinters)[]} */ (
-					Object.keys(MODULE_TRACE_DEPENDENCY_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<ModuleTraceDependencyPrinters[keyof ModuleTraceDependencyPrinters]>} */
-						(MODULE_TRACE_DEPENDENCY_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"moduleTraceDependency">} */
-							(ctx),
-							stats
-						)
-					);
-				}
-
-				for (const key of /** @type {(keyof ModuleTraceItemPrinters)[]} */ (
-					Object.keys(MODULE_TRACE_ITEM_PRINTERS)
-				)) {
-					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {NonNullable<ModuleTraceItemPrinters[keyof ModuleTraceItemPrinters]>} */
-						(MODULE_TRACE_ITEM_PRINTERS[key])(
-							obj,
-							/** @type {DefineStatsPrinterContext<"moduleTraceItem">} */
-							(ctx),
-							stats
-						)
-					);
+				// Every `*_SIMPLE_PRINTERS` map registers identically: tap
+				// `print.for(key)` with a formatter called as `(obj, ctx, stats)`.
+				// One loop over all maps replaces a dozen near-identical blocks.
+				for (const simplePrinters of /** @type {Record<string, EXPECTED_ANY>[]} */ ([
+					COMPILATION_SIMPLE_PRINTERS,
+					ASSET_SIMPLE_PRINTERS,
+					MODULE_SIMPLE_PRINTERS,
+					MODULE_ISSUER_PRINTERS,
+					MODULE_REASON_PRINTERS,
+					MODULE_PROFILE_PRINTERS,
+					CHUNK_GROUP_PRINTERS,
+					CHUNK_PRINTERS,
+					ERROR_PRINTERS,
+					LOG_ENTRY_PRINTERS,
+					MODULE_TRACE_DEPENDENCY_PRINTERS,
+					MODULE_TRACE_ITEM_PRINTERS
+				])) {
+					for (const key of Object.keys(simplePrinters)) {
+						stats.hooks.print
+							.for(key)
+							.tap(PLUGIN_NAME, (obj, ctx) =>
+								simplePrinters[key](obj, ctx, stats)
+							);
+					}
 				}
 
 				for (const key of Object.keys(PREFERRED_ORDERS)) {

package/lib/stats/StatsFactory.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
-const { concatComparators, keepOriginalOrder } = require("../util/comparators");
 const smartGrouping = require("../util/smartGrouping");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -294,10 +293,7 @@ class StatsFactory {
 				h.call(comparators, context)
 			);
 			if (comparators.length > 0) {
-				items.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators, keepOriginalOrder(items))
-				);
+				sortWithOriginalOrder(items, comparators);
 			}
 
 			// run filter on sorted items
@@ -310,23 +306,30 @@ class StatsFactory {
 				false
 			);
 
-			// for each item
+			// reuse one item context; create() spreads it synchronously, so mutating
+			// `_index`/the name key between items is safe and skips a per-item spread
+			/** @type {StatsFactoryContext} */
+			const itemContext = { ...context };
+			const itemNameType = `${type}[]`;
+			/** @type {string | void} */
+			let prevItemName;
 			let resultItems = items2.map((item, i) => {
-				/** @type {StatsFactoryContext} */
-				const itemContext = {
-					...context,
-					_index: i
-				};
+				itemContext._index = i;
 
 				// run getItemName
 				const itemName = this._forEachLevel(
 					this.hooks.getItemName,
 					this._caches.getItemName,
-					`${type}[]`,
+					itemNameType,
 					(h) => h.call(item, itemContext)
 				);
+				// drop a previous item's name key before adding this one's
+				if (prevItemName !== undefined && prevItemName !== itemName) {
+					delete itemContext[prevItemName];
+				}
 				if (itemName) itemContext[itemName] = item;
-				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
+				prevItemName = itemName;
+				const innerType = itemName ? `${type}[].${itemName}` : itemNameType;
 
 				// run getItemFactory
 				const itemFactory =
@@ -351,10 +354,7 @@ class StatsFactory {
 				(h) => h.call(comparators2, context)
 			);
 			if (comparators2.length > 0) {
-				resultItems.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators2, keepOriginalOrder(resultItems))
-				);
+				sortWithOriginalOrder(resultItems, comparators2);
 			}
 
 			// group result items
@@ -417,4 +417,33 @@ class StatsFactory {
 	}
 }
 
+/**
+ * Stable in-place sort applying comparators in order, keeping the original order
+ * 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
+ * @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>} */
+	const originalOrder = new Map();
+	for (let i = 0; i < items.length; i++) {
+		originalOrder.set(items[i], i);
+	}
+	const count = comparators.length;
+	items.sort((a, b) => {
+		for (let i = 0; i < count; i++) {
+			const res = comparators[i](a, b);
+			if (res !== 0) return res;
+		}
+		return (
+			/** @type {number} */ (originalOrder.get(a)) -
+			/** @type {number} */ (originalOrder.get(b))
+		);
+	});
+};
+
 module.exports = StatsFactory;

package/lib/url/URLParserPlugin.js

@@ -9,6 +9,9 @@ const { pathToFileURL } = require("url");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const ConstDependency = require("../dependencies/ConstDependency");
 const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
+const {
+	isImportMetaFieldEnabled
+} = require("../dependencies/ImportMetaPlugin");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
 const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
@@ -16,6 +19,7 @@ const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning")
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
+const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -78,7 +82,7 @@ const keepNewURL = (parser, expr) => {
 		/** @type {Range} */ (arg2.range),
 		[RuntimeGlobals.baseURI]
 	);
-	dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+	dep.loc = parser.getLocation(expr);
 	parser.state.module.addPresentationalDependency(dep);
 };
 
@@ -89,9 +93,10 @@ const getEvaluatedExprCache = new WeakMap();
  * Gets evaluated expr.
  * @param {NewExpressionNode} expr expression
  * @param {JavascriptParser} parser parser parser
+ * @param {boolean} importMetaUrlEnabled true when import.meta.url should be handled
  * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
  */
-const getEvaluatedExpr = (expr, parser) => {
+const getEvaluatedExpr = (expr, parser, importMetaUrlEnabled) => {
 	let result = getEvaluatedExprCache.get(expr);
 	if (result !== undefined) return result;
 
@@ -107,7 +112,9 @@ const getEvaluatedExpr = (expr, parser) => {
 		if (arg2.type !== "MemberExpression" || arg1.type === "SpreadElement") {
 			return;
 		}
-		if (!isMetaUrl(parser, arg2)) return;
+		if (!importMetaUrlEnabled || !isMetaUrl(parser, arg2)) {
+			return;
+		}
 
 		return parser.evaluateExpression(arg1);
 	};
@@ -118,6 +125,13 @@ const getEvaluatedExpr = (expr, parser) => {
 	return result;
 };
 
+/**
+ * @typedef {object} ResolvedResourceHints
+ * @property {boolean=} prefetch project-wide prefetch default
+ * @property {boolean=} preload project-wide preload default
+ * @property {("low" | "high" | "auto" | false)=} fetchPriority project-wide fetchPriority default
+ */
+
 class URLParserPlugin {
 	/**
 	 * Creates an instance of URLParserPlugin.
@@ -135,10 +149,18 @@ class URLParserPlugin {
 	 */
 	apply(parser) {
 		const relative = this.options.url === "relative";
+		const importMetaUrlEnabled = isImportMetaFieldEnabled(
+			this.options.importMeta,
+			"url"
+		);
 
 		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
 		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (!request) return;
@@ -159,7 +181,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							/** @type {DependencyLocation} */ (comment.loc)
+							parser.getLocation(comment)
 						)
 					);
 				}
@@ -170,7 +192,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 					return;
@@ -179,7 +201,11 @@ class URLParserPlugin {
 
 					const [, arg2] = expr.arguments;
 
-					if (arg2.type !== "MemberExpression" || !isMetaUrl(parser, arg2)) {
+					if (
+						arg2.type !== "MemberExpression" ||
+						!importMetaUrlEnabled ||
+						!isMetaUrl(parser, arg2)
+					) {
 						return;
 					}
 
@@ -189,7 +215,11 @@ class URLParserPlugin {
 				}
 			}
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			if (!evaluatedExpr) return;
 
 			/** @type {string | undefined} */
@@ -213,8 +243,27 @@ class URLParserPlugin {
 					/** @type {Range} */ (expr.range),
 					relative
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
+				// `parser.javascript.urlHints` provides project-wide defaults
+				// (resolved per-request, with `test` / `include` / `exclude`
+				// matching); a per-URL magic comment for the same hint wins
+				// when both are set.
+				ResourceHintPlugin.applyResourceHints(
+					dep,
+					this.options.urlHints,
+					request,
+					importOptions,
+					parser.state.module,
+					parser.getLocation(expr)
+				);
 				parser.state.current.addDependency(dep);
+				// For ESM module output the template embeds the asset's resolved
+				// filename, so the asset must be code-generated first. Only added in
+				// that mode — a code-gen dependency on an asset that a later watch
+				// rebuild leaves unaffected can otherwise deadlock the scheduler.
+				if (parser.state.compilation.options.output.module) {
+					parser.state.module.addCodeGenerationDependency(dep);
+				}
 				getInnerGraphUtils(parser.state.compilation).onUsage(
 					parser.state,
 					(e) => (dep.usedByExports = e)
@@ -239,7 +288,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -254,7 +303,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -278,7 +327,7 @@ class URLParserPlugin {
 				parser
 			);
 			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
 			return true;
@@ -290,7 +339,11 @@ class URLParserPlugin {
 			const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
 			if (!calleeInfo || calleeInfo.name !== "URL") return;
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (request) return true;