webpack 5.59.0 → 5.71.0

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -10,7 +10,9 @@ const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 
@@ -19,6 +21,7 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
 /** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
@@ -60,8 +63,18 @@ function getAssertions(node) {
 }
 
 module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
-		this.strictExportPresence = options.strictExportPresence;
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
@@ -70,6 +83,19 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
+		const { exportPresenceMode } = this;
+
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
+		function getNonOptionalMemberChain(node, count) {
+			while (count--) node = node.object;
+			return node;
+		}
+
 		parser.hooks.isPure
 			.for("Identifier")
 			.tap("HarmonyImportDependencyParserPlugin", expression => {
@@ -118,74 +144,145 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				return true;
 			}
 		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
+		parser.hooks.binaryExpression.tap(
+			"HarmonyImportDependencyParserPlugin",
+			expression => {
+				if (expression.operator !== "in") return;
+
+				const leftPartEvaluated = parser.evaluateExpression(expression.left);
+				if (leftPartEvaluated.couldHaveSideEffects()) return;
+				const leftPart = leftPartEvaluated.asString();
+				if (!leftPart) return;
+
+				const rightPart = parser.evaluateExpression(expression.right);
+				if (!rightPart.isIdentifier()) return;
+
+				const rootInfo = rightPart.rootInfo;
+				if (
+					!rootInfo ||
+					!rootInfo.tagInfo ||
+					rootInfo.tagInfo.tag !== harmonySpecifierTag
+				)
+					return;
+				const settings = rootInfo.tagInfo.data;
+				const members = rightPart.getMembers();
+				const dep = new HarmonyEvaluatedImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
-					settings.ids,
+					settings.ids.concat(members).concat([leftPart]),
 					settings.name,
-					expr.range,
-					this.strictExportPresence,
-					settings.assertions
+					expression.range,
+					settings.assertions,
+					"in"
 				);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
+				dep.directImport = members.length === 0;
+				dep.asiSafe = !parser.isAsiPosition(expression.range[0]);
+				dep.loc = expression.loc;
 				parser.state.module.addDependency(dep);
 				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 				return true;
-			});
-		parser.hooks.expressionMemberChain
+			}
+		);
+		parser.hooks.expression
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
-					ids,
+					settings.ids,
 					settings.name,
 					expr.range,
-					this.strictExportPresence,
+					exportPresenceMode,
 					settings.assertions
 				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
 				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
 				dep.loc = expr.loc;
 				parser.state.module.addDependency(dep);
 				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 				return true;
 			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals) => {
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									expression,
+									members.length - nonOptionalMembers.length
+							  )
+							: expression;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						expr.range,
+						exportPresenceMode,
+						settings.assertions
+					);
+					dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		parser.hooks.callMemberChain
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const { arguments: args, callee } = expr;
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					callee.range,
-					this.strictExportPresence,
-					settings.assertions
-				);
-				dep.directImport = members.length === 0;
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
-				// only in case when we strictly follow the spec we need a special case here
-				dep.namespaceObjectAsContext =
-					members.length > 0 && this.strictThisContextOnImports;
-				dep.loc = callee.loc;
-				parser.state.module.addDependency(dep);
-				if (args) parser.walkExpressions(args);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals) => {
+					const { arguments: args, callee } = expression;
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									callee,
+									members.length - nonOptionalMembers.length
+							  )
+							: callee;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						expr.range,
+						exportPresenceMode,
+						settings.assertions
+					);
+					dep.directImport = members.length === 0;
+					dep.call = true;
+					dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+					// only in case when we strictly follow the spec we need a special case here
+					dep.namespaceObjectAsContext =
+						members.length > 0 && this.strictThisContextOnImports;
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					if (args) parser.walkExpressions(args);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
 		hotAcceptCallback.tap(

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -28,6 +28,8 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 
 const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
+const { ExportPresenceModes } = HarmonyImportDependency;
+
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	constructor(
 		request,
@@ -35,14 +37,14 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		ids,
 		name,
 		range,
-		strictExportPresence,
+		exportPresenceMode,
 		assertions
 	) {
 		super(request, sourceOrder, assertions);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;
-		this.strictExportPresence = strictExportPresence;
+		this.exportPresenceMode = exportPresenceMode;
 		this.namespaceObjectAsContext = false;
 		this.call = undefined;
 		this.directImport = undefined;
@@ -153,19 +155,29 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return [ids];
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
 	/**
 	 * Returns warnings
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[]} warnings
 	 */
 	getWarnings(moduleGraph) {
-		if (
-			this.strictExportPresence ||
-			moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-		) {
-			return null;
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
 		}
-		return this._getErrors(moduleGraph);
+		return null;
 	}
 
 	/**
@@ -174,10 +186,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {WebpackError[]} errors
 	 */
 	getErrors(moduleGraph) {
-		if (
-			this.strictExportPresence ||
-			moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-		) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
 			return this._getErrors(moduleGraph);
 		}
 		return null;
@@ -209,7 +219,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.ids);
 		write(this.name);
 		write(this.range);
-		write(this.strictExportPresence);
+		write(this.exportPresenceMode);
 		write(this.namespaceObjectAsContext);
 		write(this.call);
 		write(this.directImport);
@@ -224,7 +234,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.ids = read();
 		this.name = read();
 		this.range = read();
-		this.strictExportPresence = read();
+		this.exportPresenceMode = read();
 		this.namespaceObjectAsContext = read();
 		this.call = read();
 		this.directImport = read();
@@ -251,14 +261,32 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
-		const { moduleGraph, module, runtime, concatenationScope } =
-			templateContext;
+		const { moduleGraph, runtime } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
 		// Skip rendering depending when dependency is conditional
 		if (connection && !connection.isTargetActive(runtime)) return;
 
 		const ids = dep.getIds(moduleGraph);
+		const exportExpr = this._getCodeForIds(dep, source, templateContext, ids);
+		const range = dep.range;
+		if (dep.shorthand) {
+			source.insert(range[1], `: ${exportExpr}`);
+		} else {
+			source.replace(range[0], range[1] - 1, exportExpr);
+		}
+	}
 
+	/**
+	 * @param {HarmonyImportSpecifierDependency} dep dependency
+	 * @param {ReplaceSource} source source
+	 * @param {DependencyTemplateContext} templateContext context
+	 * @param {string[]} ids ids
+	 * @returns {string} generated code
+	 */
+	_getCodeForIds(dep, source, templateContext, ids) {
+		const { moduleGraph, module, runtime, concatenationScope } =
+			templateContext;
+		const connection = moduleGraph.getConnection(dep);
 		let exportExpr;
 		if (
 			connection &&
@@ -289,7 +317,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				);
 			}
 		} else {
-			super.apply(dependency, source, templateContext);
+			super.apply(dep, source, templateContext);
 
 			const { runtimeTemplate, initFragments, runtimeRequirements } =
 				templateContext;
@@ -310,11 +338,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				runtimeRequirements
 			});
 		}
-		if (dep.shorthand) {
-			source.insert(dep.range[1], `: ${exportExpr}`);
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, exportExpr);
-		}
+		return exportExpr;
 	}
 };
 

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -8,6 +8,7 @@
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
@@ -59,6 +60,15 @@ class HarmonyModulesPlugin {
 					new HarmonyImportSpecifierDependency.Template()
 				);
 
+				compilation.dependencyFactories.set(
+					HarmonyEvaluatedImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyEvaluatedImportSpecifierDependency,
+					new HarmonyEvaluatedImportSpecifierDependency.Template()
+				);
+
 				compilation.dependencyTemplates.set(
 					HarmonyExportHeaderDependency,
 					new HarmonyExportHeaderDependency.Template()

package/lib/dependencies/ImportContextDependency.js

@@ -28,7 +28,6 @@ class ImportContextDependency extends ContextDependency {
 	serialize(context) {
 		const { write } = context;
 
-		write(this.range);
 		write(this.valueRange);
 
 		super.serialize(context);
@@ -37,7 +36,6 @@ class ImportContextDependency extends ContextDependency {
 	deserialize(context) {
 		const { read } = context;
 
-		this.range = read();
 		this.valueRange = read();
 
 		super.deserialize(context);

package/lib/dependencies/ImportMetaContextDependency.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+class ImportMetaContextDependency extends ContextDependency {
+	constructor(options, range) {
+		super(options);
+
+		this.range = range;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return `import.meta.webpackContext ${this.options.mode}`;
+	}
+}
+
+makeSerializable(
+	ImportMetaContextDependency,
+	"webpack/lib/dependencies/ImportMetaContextDependency"
+);
+
+ImportMetaContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = ImportMetaContextDependency;