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

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/HtmlEntryDependency.js

@@ -194,7 +194,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const chunksLoadedByAncestorTags = new Set();
 	/** @type {Set<import("../ChunkGroup")>} */
 	const visitedGroups = new Set();
-	const walk = (/** @type {import("../ChunkGroup")} */ group) => {
+	/**
+	 * Collects the chunks an ancestor entry's own tags already load.
+	 * @param {import("../ChunkGroup")} group chunk group to walk up from
+	 * @returns {void}
+	 */
+	const walk = (group) => {
 		if (visitedGroups.has(group)) return;
 		visitedGroups.add(group);
 		for (const parent of group.parentsIterable) {
@@ -220,7 +225,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const ordered = [];
 	/** @type {Set<Chunk>} */
 	const seen = new Set();
-	const push = (/** @type {Chunk | null | undefined} */ chunk) => {
+	/**
+	 * Appends a chunk once, skipping the ones an ancestor entry already loads.
+	 * @param {Chunk | null | undefined} chunk chunk to append
+	 * @returns {void}
+	 */
+	const push = (chunk) => {
 		if (!chunk || seen.has(chunk) || chunk === entryChunk) return;
 		if (chunksLoadedByAncestorTags.has(chunk)) return;
 		seen.add(chunk);

package/lib/dependencies/ImportContextDependency.js

@@ -8,11 +8,13 @@
 const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "../serialization/ObjectMiddleware" */
 /** @import { ContextDependencyOptions } from "./ContextDependency" */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 class ImportContextDependency extends ContextDependency {
 	/**
@@ -26,6 +28,8 @@ class ImportContextDependency extends ContextDependency {
 
 		this.range = range;
 		this.valueRange = valueRange;
+		/** @type {Range | undefined} */
+		this.optionsRange = undefined;
 	}
 
 	get type() {
@@ -56,6 +60,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	serialize(context) {
 		context.write(this.valueRange);
+		context.write(this.optionsRange);
 
 		super.serialize(context);
 	}
@@ -66,6 +71,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	deserialize(context) {
 		this.valueRange = context.read();
+		this.optionsRange = context.read();
 
 		super.deserialize(context.rest);
 	}
@@ -76,6 +82,40 @@ makeSerializable(
 	"webpack/lib/dependencies/ImportContextDependency"
 );
 
-ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+ImportContextDependency.Template = class ImportContextDependencyTemplate extends (
+	ContextDependencyTemplateAsRequireCall
+) {
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const optionsRange = /** @type {ImportContextDependency} */ (dep)
+			.optionsRange;
+		if (optionsRange === undefined) {
+			super.replaceCall(dep, source, moduleExports, templateContext);
+			return;
+		}
+		// Request then options, in that order; their own source is kept so
+		// nested dependencies in them still get their replacements.
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		const check = importOptionsCheck(
+			templateContext.runtimeTemplate,
+			["r", "o"],
+			`${moduleExports}(r)`
+		);
+		source.replace(range[0], valueRange[0] - 1, `(${check})(`);
+		// The options range excludes any parentheses the source had, so a comma
+		// expression would otherwise split into arguments of its own.
+		source.replace(valueRange[1], optionsRange[0] - 1, ", (");
+		source.replace(optionsRange[1], range[1] - 1, "))");
+	}
+};
 
 module.exports = ImportContextDependency;

package/lib/dependencies/ImportDependency.js

@@ -6,11 +6,11 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
@@ -226,35 +226,14 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 		}
 
 		// A non-static second argument must still be evaluated (for its side
-		// effects and evaluation order) and validated per spec. Keep it in place
-		// and wrap it in an inline validator that mirrors the runtime checks of
-		// the spec's `import(specifier, options)` evaluation.
+		// effects and evaluation order) and checked per spec, so keep it in place
+		// and wrap it.
 		if (dep.optionsRange) {
-			const validator = runtimeTemplate.basicFunction("o", [
-				"try {",
-				Template.indent([
-					"if (o !== undefined) {",
-					Template.indent([
-						'if ((typeof o !== "object" && typeof o !== "function") || o === null) throw new TypeError("The second argument to import() must be an object");',
-						'var a = o["with"];',
-						"if (a !== undefined) {",
-						Template.indent([
-							'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
-							"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
-							Template.indent([
-								'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
-							]),
-							"}"
-						]),
-						"}"
-					]),
-					"}"
-				]),
-				"} catch (e) { return Promise.reject(e); }",
-				`return ${content};`
-			]);
-			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${validator})(`);
-			source.replace(dep.optionsRange[1], dep.range[1] - 1, ")");
+			const check = importOptionsCheck(runtimeTemplate, ["o"], content);
+			// The options range excludes any parentheses the source had, so a
+			// comma expression would otherwise split into arguments of its own.
+			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${check})((`);
+			source.replace(dep.optionsRange[1], dep.range[1] - 1, "))");
 			return;
 		}
 

package/lib/dependencies/ImportParserPlugin.js

@@ -209,20 +209,18 @@ const isStaticStringAttributes = (node) => {
 				: key.type === "Literal"
 					? key.value
 					: undefined;
-		if (keyName === "with" || keyName === "assert") {
-			const value = prop.value;
-			if (value.type !== "ObjectExpression") return false;
-			for (const attr of value.properties) {
-				if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
-					return false;
-				}
-				const attrValue = attr.value;
-				if (
-					attrValue.type !== "Literal" ||
-					typeof attrValue.value !== "string"
-				) {
-					return false;
-				}
+		// Any other key is an expression webpack cannot account for, and its
+		// value still evaluates, so the argument has to stay.
+		if (keyName !== "with" && keyName !== "assert") return false;
+		const value = prop.value;
+		if (value.type !== "ObjectExpression") return false;
+		for (const attr of value.properties) {
+			if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
+				return false;
+			}
+			const attrValue = attr.value;
+			if (attrValue.type !== "Literal" || typeof attrValue.value !== "string") {
+				return false;
 			}
 		}
 	}
@@ -676,6 +674,18 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
+				// The context module ignores the options argument, but the spec
+				// evaluates it, so anything but a static attributes object stays.
+				const optionsNode = expr.options;
+				if (
+					optionsNode &&
+					optionsNode.range &&
+					!isStaticStringAttributes(optionsNode)
+				) {
+					/** @type {ImportContextDependency} */ (dep).optionsRange =
+						/** @type {Range} */ (optionsNode.range);
+					parser.walkExpression(optionsNode);
+				}
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);

package/lib/dependencies/RequireHeaderDependency.js

@@ -76,30 +76,29 @@ RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends
 		{ moduleGraph, runtime, runtimeRequirements, concatenationScope }
 	) {
 		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-
-		// the paired require dependency already replaced the whole call
-		if (
-			concatenationScope !== undefined &&
-			concatenationScope.isInsideReplacedRequire(dep.range[0])
-		) {
-			return;
-		}
-
 		const requireDep = dep.requireDependency;
-		// Skip when the paired call became `0`; dead-branch still needs the header.
 		if (requireDep) {
 			const connection = moduleGraph.getConnection(requireDep);
-			if (
-				connection &&
-				!connection.isTargetActive(runtime) &&
-				requireDep.isEvaluationOnly()
-			) {
-				const guards = requireDep.branchGuards;
-				if (
-					guards === undefined ||
-					!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
-				) {
-					return;
+			if (connection) {
+				if (connection.isTargetActive(runtime)) {
+					if (
+						concatenationScope !== undefined &&
+						requireDep.rendersAsConcatenatedReference(
+							connection,
+							concatenationScope
+						)
+					) {
+						return;
+					}
+				} else if (requireDep.isEvaluationOnly()) {
+					// Skip when the paired call became `0`; dead-branch still needs the header.
+					const guards = requireDep.branchGuards;
+					if (
+						guards === undefined ||
+						!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+					) {
+						return;
+					}
 				}
 			}
 		}

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/dependencies/importOptionsCheck.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+
+/**
+ * Wraps an import so its arguments evaluate in source order and the options are
+ * checked, rejecting rather than throwing. The last parameter holds them.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {string[]} parameters parameter names, the options one last
+ * @param {string} content the import expression to return once the check passes
+ * @returns {string} the wrapping function
+ */
+const importOptionsCheck = (runtimeTemplate, parameters, content) => {
+	const options = parameters[parameters.length - 1];
+	return runtimeTemplate.basicFunction(parameters.join(", "), [
+		"try {",
+		Template.indent([
+			`if (${options} !== undefined) {`,
+			Template.indent([
+				`if ((typeof ${options} !== "object" && typeof ${options} !== "function") || ${options} === null) throw new TypeError("The second argument to import() must be an object");`,
+				`var a = ${options}["with"];`,
+				"if (a !== undefined) {",
+				Template.indent([
+					'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+					"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+					Template.indent([
+						'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+					]),
+					"}"
+				]),
+				"}"
+			]),
+			"}"
+		]),
+		"} catch (e) { return Promise.reject(e); }",
+		`return ${content};`
+	]);
+};
+
+module.exports = importOptionsCheck;

package/lib/errors/DotenvFileError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * Error for a dotenv file that exists but could not be read. An absent file is
+ * normal and reported through `missingDependencies` instead.
+ */
+class DotenvFileError extends WebpackError {
+	/**
+	 * @param {string} file path of the dotenv file
+	 * @param {Error} error underlying file system error
+	 */
+	constructor(file, error) {
+		super(`Unable to read the dotenv file ${file}\n${error.message}`);
+
+		this.name = "DotenvFileError";
+		/** @type {string} */
+		this.file = file;
+		this.error = error;
+	}
+}
+
+module.exports = DotenvFileError;

package/lib/errors/ImportedBindingAssignmentError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class ImportedBindingAssignmentError extends WebpackError {
+	/**
+	 * Creates an instance of ImportedBindingAssignmentError.
+	 * @param {string} name the local name of the namespace binding
+	 */
+	constructor(name) {
+		super(
+			`Assignment to the imported binding '${name}'. A namespace import is immutable, so this throws a TypeError where the module is a real ES module.`
+		);
+
+		this.name = "ImportedBindingAssignmentError";
+	}
+}
+
+makeSerializable(
+	ImportedBindingAssignmentError,
+	"webpack/lib/errors/ImportedBindingAssignmentError"
+);
+
+module.exports = ImportedBindingAssignmentError;

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);