webpack 5.110.1 → 5.110.2

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -43,6 +43,7 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import Module from "../Module" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /**
  * @import JavascriptParser, {
  * 	ImportAttributes,
@@ -71,10 +72,24 @@ const EMPTY_ID_RANGES = [];
  * @property {boolean} await
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType} phase
+ * @property {boolean} used whether the binding is referenced anywhere
+ * @property {HarmonyImportSideEffectDependency | undefined} dependency the statement's own dependency
  */
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
+/**
+ * Records that an import binding is referenced, so it is not reported as an
+ * unused specifier naming a missing export.
+ * @param {HarmonySettings | undefined} settings settings of the referenced tag
+ * @returns {boolean} true when the reference was a harmony import specifier
+ */
+const markUsed = (settings) => {
+	if (!settings) return false;
+	settings.used = true;
+	return true;
+};
+
 /**
  * Gets in operator harmony import info.
  * @param {JavascriptParser} parser the parser
@@ -107,6 +122,7 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	if (!settings) {
 		return;
 	}
+	settings.used = true;
 
 	return {
 		leftPart,
@@ -125,7 +141,10 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 const findImportSpecifier = (parser, node) => {
 	switch (node.type) {
 		case "Identifier":
-			return Boolean(parser.getTagData(node.name, harmonySpecifierTag));
+			return markUsed(
+				/** @type {HarmonySettings | undefined} */
+				(parser.getTagData(node.name, harmonySpecifierTag))
+			);
 		case "UnaryExpression":
 			return findImportSpecifier(
 				parser,
@@ -213,6 +232,35 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
+		// Parsers are reused across modules, so both are reset per program.
+		/** @type {HarmonySettings[]} */
+		const declaredSpecifiers = [];
+		/** @type {HarmonyImportSideEffectDependency | undefined} */
+		let lastSideEffectDependency;
+
+		parser.hooks.program.tap(PLUGIN_NAME, () => {
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+		});
+		parser.hooks.finish.tap(PLUGIN_NAME, () => {
+			for (const settings of declaredSpecifiers) {
+				const dependency = settings.dependency;
+				if (dependency === undefined || settings.used) continue;
+				if (dependency.unusedSpecifiers === undefined) {
+					dependency.unusedSpecifiers = {
+						exportPresenceMode: this.exportPresenceMode,
+						specifiers: []
+					};
+				}
+				dependency.unusedSpecifiers.specifiers.push([
+					settings.ids,
+					settings.name
+				]);
+			}
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+		});
+
 		/**
 		 * Gets non optional member chain.
 		 * @param {MemberExpression} node member expression
@@ -228,7 +276,10 @@ class HarmonyImportDependencyParserPlugin {
 			const expr = /** @type {Identifier} */ (expression);
 			if (
 				parser.isVariableDefined(expr.name) ||
-				parser.getTagData(expr.name, harmonySpecifierTag)
+				markUsed(
+					/** @type {HarmonySettings | undefined} */
+					(parser.getTagData(expr.name, harmonySpecifierTag))
+				)
 			) {
 				return true;
 			}
@@ -267,6 +318,7 @@ class HarmonyImportDependencyParserPlugin {
 			);
 			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
+			lastSideEffectDependency = sideEffectDep;
 			return true;
 		});
 		parser.hooks.importSpecifier.tap(
@@ -274,18 +326,20 @@ class HarmonyImportDependencyParserPlugin {
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
 				const phase = getImportPhase(parser, statement);
-				parser.tagVariable(
+				const settings = /** @type {HarmonySettings} */ ({
 					name,
-					harmonySpecifierTag,
-					/** @type {HarmonySettings} */ ({
-						name,
-						source,
-						ids,
-						sourceOrder: parser.state.lastHarmonyImportOrder,
-						attributes: getImportAttributes(statement),
-						phase
-					})
-				);
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					attributes: getImportAttributes(statement),
+					phase,
+					used: false,
+					dependency: lastSideEffectDependency
+				});
+				parser.tagVariable(name, harmonySpecifierTag, settings);
+				// The statement's dependency carries them, so a never-referenced
+				// one still resolves; a namespace import names no export.
+				if (ids.length !== 0) declaredSpecifiers.push(settings);
 				return true;
 			}
 		);
@@ -328,16 +382,28 @@ class HarmonyImportDependencyParserPlugin {
 					nameInfo &&
 					nameInfo.rootInfo instanceof VariableInfo &&
 					nameInfo.rootInfo.name &&
-					parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag)
+					markUsed(
+						/** @type {HarmonySettings | undefined} */
+						(parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag))
+					)
 				) {
 					return true;
 				}
 			}
 		);
+		// Concatenation would turn the binding into a plain local, losing the
+		// getter-only property whose write throws.
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, () => {
+			markUsed(/** @type {HarmonySettings} */ (parser.currentTagData));
+			/** @type {JavascriptModuleBuildInfo} */
+			(parser.state.module.buildInfo).moduleConcatenationBailout =
+				"assignment to an imported binding";
+		});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
 
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
@@ -376,6 +442,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings =
 						/** @type {HarmonySettings} */
 						(parser.currentTagData);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -431,6 +498,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -491,6 +559,7 @@ class HarmonyImportDependencyParserPlugin {
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expression, members) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
 				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
 				if (expression.operator !== "=") return;
 				if (members.length !== 1) return;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -13,6 +13,8 @@ const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
+const { ExportPresenceModes } = HarmonyImportDependency;
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import { GetConditionFn, LazyUntil } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
@@ -20,6 +22,19 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @import { ConnectionState } from "../ModuleGraphConnection" */
 /** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
+/** @import { JavascriptModuleBuildMeta } from "../javascript/JavascriptModule" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { ObjectSerializerContext, ObjectDeserializerContext } from "../serialization/ObjectMiddleware" */
+
+/**
+ * Specifiers the module declares but never reads, with the presence level to
+ * report them at. Allocated only for a module that has one, so the common
+ * import pays a single empty slot.
+ * @typedef {object} UnusedSpecifiers
+ * @property {ExportPresenceMode} exportPresenceMode
+ * @property {[Ids, string][]} specifiers
+ */
 
 class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	/**
@@ -31,12 +46,111 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 */
 	constructor(request, sourceOrder, phase, attributes) {
 		super(request, sourceOrder, phase, attributes);
+		/** @type {UnusedSpecifiers | undefined} */
+		this.unusedSpecifiers = undefined;
 	}
 
 	get type() {
 		return "harmony side effect evaluation";
 	}
 
+	/**
+	 * Returns warnings.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.WARN
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Get effective export presence level.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.unusedSpecifiers === undefined) return ExportPresenceModes.NONE;
+		const mode = this.unusedSpecifiers.exportPresenceMode;
+		if (mode !== ExportPresenceModes.AUTO) return mode;
+		const buildMeta =
+			/** @type {JavascriptModuleBuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
+		return buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
+	/**
+	 * Returns errors.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} errors
+	 */
+	getErrors(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.ERROR
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Linking errors for specifiers the module declares but never references.
+	 * The spec resolves every import entry, so a name that does not exist is a
+	 * link error whether or not the binding is read.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getUnusedSpecifierErrors(moduleGraph) {
+		// Both callers resolve the presence level first, which is NONE without
+		// specifiers, so this only runs when there are some.
+		const { specifiers } = /** @type {UnusedSpecifiers} */ (
+			this.unusedSpecifiers
+		);
+		/** @type {WebpackError[] | undefined} */
+		let errors;
+		for (const [ids, name] of specifiers) {
+			const linkingErrors = this.getLinkingErrors(
+				moduleGraph,
+				ids,
+				`(imported as '${name}')`
+			);
+			if (linkingErrors) {
+				if (errors === undefined) errors = linkingErrors;
+				else errors.push(...linkingErrors);
+			}
+		}
+		return errors;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.unusedSpecifiers);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.unusedSpecifiers = context.read();
+		super.deserialize(context);
+	}
+
 	/**
 	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
 	 * @returns {string | true | null} export name, true for all exports, null for none

package/lib/dependencies/WorkerAndWorkletPlugin.js

@@ -753,6 +753,7 @@ class WorkerAndWorkletPlugin {
 										) {
 											return;
 										}
+										settings.used = true;
 										return handle(expr);
 									});
 							} else {

package/lib/dependencies/WorkerDependency.js

@@ -136,19 +136,13 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		// and webpack itself can statically follow the worker. A resource hint doesn't
 		// block it: the `<link>` is emitted at chunk startup instead of wrapping the href,
 		// which would turn the specifier into a non-analyzable expression.
-		const analyzableSpecifier = runtimeTemplate.supportsAnalyzable(
-			"url",
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			chunk,
+			templateContext.module,
 			chunkGraph,
-			templateContext.module
-		)
-			? runtimeTemplate._getAnalyzableChunkSpecifier(
-					dep.options.publicPath,
-					chunk,
-					templateContext.module,
-					chunkGraph,
-					runtimeRequirements
-				)
-			: null;
+			runtimeRequirements
+		);
 
 		if (analyzableSpecifier !== null) {
 			// No `<link>` helper is asked for here: this form emits no call, and

package/lib/dependencies/WorkletDependency.js

@@ -140,17 +140,13 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
 		// and webpack itself can statically follow the worklet. The worklet chunk links its
 		// splits via native `import`, so only the entry chunk is referenced.
-		const analyzableSpecifier =
-			runtimeTemplate.supportsAnalyzable("url", chunkGraph, module) &&
-			entryChunk.id !== null
-				? runtimeTemplate._getAnalyzableChunkSpecifier(
-						dep.options.publicPath,
-						entryChunk,
-						module,
-						chunkGraph,
-						runtimeRequirements
-					)
-				: null;
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			entryChunk,
+			module,
+			chunkGraph,
+			runtimeRequirements
+		);
 		if (analyzableSpecifier !== null) {
 			source.replace(
 				dep.callRange[0],

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -120,15 +120,12 @@ class ModuleChunkLoadingPlugin {
 						if (!isEnabledForChunk(chunk)) return;
 						// A baked url carries where the chunk is, so neither is read for it.
 						// Asked as the runtime module asks, so the two always agree.
-						if (
-							compilation.runtimeTemplate.analyzableChunkScriptUrls(
-								chunk,
-								chunkGraph,
-								set
-							) !== null
-						) {
-							return;
-						}
+						const baked = compilation.runtimeTemplate.analyzableChunkScriptUrls(
+							chunk,
+							chunkGraph,
+							set
+						);
+						if (baked !== null && baked.complete) return;
 						set.add(RuntimeGlobals.publicPath);
 						set.add(RuntimeGlobals.getChunkScriptFilename);
 					});

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -129,7 +129,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs);
 		// Under module output each hinted chunk is a known file, so the urls are written
 		// out and read by id rather than built from the chunk id at runtime.
-		const chunkUrls =
+		const bakedChunkUrls =
 			withPrefetch || withPreload
 				? runtimeTemplate.analyzableChunkScriptUrls(
 						chunk,
@@ -138,6 +138,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 						this
 					)
 				: null;
+		// A hint is best-effort, so an id an incomplete map lacks is not worth a per-id
+		// fallback — only a complete map replaces the runtime name lookup.
+		const chunkUrls =
+			bakedChunkUrls !== null && bakedChunkUrls.complete
+				? bakedChunkUrls.urls
+				: null;
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);

package/lib/html/HtmlModulesPlugin.js

@@ -31,7 +31,7 @@ const preloadModuleType = require("../util/preloadModuleType");
 const {
 	PUBLIC_PATH_AUTO: autoPlaceholder
 } = require("../util/publicPathPlaceholder");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 const HtmlModule = require("./HtmlModule");
 
 const getMimeTypes = memoize(() => require("../util/mimeTypes"));
@@ -222,6 +222,9 @@ const isIntegrityEnabled = (integrity) =>
 // `\.html`/`\.css` request matchers for the synthetic `output.html` wrapper.
 const HTML_REQUEST_RE = /\.html(\?|$)/i;
 const CSS_REQUEST_RE = /\.css(\?|$)/i;
+// The wrapper's own resource — the media type must end here, so that a
+// `data:text/htmlx,` entry (JavaScript to `DataUriPlugin`) is not one.
+const HTML_DATA_URL_RE = /^data:text\/html[,;]/i;
 
 /**
  * Requests an `output.html` page must load for an entry: its `dependOn`
@@ -714,28 +717,64 @@ class HtmlModulesPlugin {
 						// An inlined chunk file is dead weight once nothing else references
 						// it by URL (another page's tag, or the runtime's async chunk map);
 						// a content-hashed filename makes a substring hit a real reference.
+						/** @type {Set<string>} */
+						const deletionCandidates = new Set(inlinedFiles);
+						// A wrapper entry's chunk only rebuilds the page's own markup; the
+						// page loads the `<script src>` entries the parser split out of it.
+						for (const entrypoint of compilation.entrypoints.values()) {
+							const chunk = entrypoint.getEntrypointChunk();
+							if (!chunk) continue;
+							let wrapperOnly = false;
+							for (const entryModule of compilation.chunkGraph.getChunkEntryModulesIterable(
+								chunk
+							)) {
+								const { resource } = /** @type {import("../NormalModule")} */ (
+									entryModule
+								);
+								wrapperOnly =
+									typeof resource === "string" &&
+									HTML_DATA_URL_RE.test(resource);
+								if (!wrapperOnly) break;
+							}
+							if (!wrapperOnly) continue;
+							for (const file of chunk.files) deletionCandidates.add(file);
+						}
 						// Materialize each other asset's source once (it can be expensive to
-						// render) and test all inlined files against it, rather than
-						// re-materializing every asset per inlined file.
-						if (inlinedFiles.size > 0) {
+						// render) and test all candidates against it, rather than
+						// re-materializing every asset per candidate.
+						if (deletionCandidates.size > 0) {
 							/** @type {Set<string>} */
 							const stillReferenced = new Set();
-							for (const name of Object.keys(compilation.assets)) {
-								if (
-									inlinedFiles.has(name) ||
-									stillReferenced.size === inlinedFiles.size
-								) {
-									continue;
-								}
+							/** @type {string[]} */
+							const pending = [];
+							/**
+							 * @param {string} name asset whose source may name a candidate
+							 */
+							const markReferenced = (name) => {
 								const source = compilation.assets[name].source();
-								if (typeof source !== "string") continue;
-								for (const file of inlinedFiles) {
+								if (typeof source !== "string") return;
+								for (const file of deletionCandidates) {
 									if (!stillReferenced.has(file) && source.includes(file)) {
 										stillReferenced.add(file);
+										pending.push(file);
 									}
 								}
+							};
+							for (const name of Object.keys(compilation.assets)) {
+								if (
+									deletionCandidates.has(name) ||
+									stillReferenced.size === deletionCandidates.size
+								) {
+									continue;
+								}
+								markReferenced(name);
+							}
+							// A kept candidate can reference another through its async chunk
+							// map, so follow each until nothing new is kept.
+							while (pending.length > 0) {
+								markReferenced(/** @type {string} */ (pending.pop()));
 							}
-							for (const file of inlinedFiles) {
+							for (const file of deletionCandidates) {
 								if (!stillReferenced.has(file)) compilation.deleteAsset(file);
 							}
 						}
@@ -896,14 +935,14 @@ class HtmlModulesPlugin {
 					PLUGIN_NAME,
 					(result, module) => {
 						if (module.type === HTML_MODULE_TYPE) {
-							const [source, ...rest] = result;
+							const [source, ...rest] = removeBOMFromResult(result);
 							// `applyTemplate` is a no-op unless `module.parser.html.template`
 							// is set. Running it here (where the returned source becomes the
 							// module's stored source) keeps the parser's dependency offsets
 							// and the generator's render base in sync.
 							const parser = /** @type {HtmlParser} */ (module.parser);
 
-							return [parser.applyTemplate(removeBOM(source), module), ...rest];
+							return [parser.applyTemplate(source, module), ...rest];
 						}
 
 						return result;