webpack 5.59.0 → 5.94.0

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -0,0 +1,152 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder source order
+	 * @param {TODO} ids ids
+	 * @param {TODO} name name
+	 * @param {Range} range location in source code
+	 * @param {ImportAttributes} attributes import assertions
+	 * @param {string} operator operator
+	 */
+	constructor(request, sourceOrder, ids, name, range, attributes, operator) {
+		super(request, sourceOrder, ids, name, range, false, attributes, []);
+		this.operator = operator;
+	}
+
+	get type() {
+		return `evaluated X ${this.operator} harmony import specifier`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.operator);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.operator = read();
+	}
+}
+
+makeSerializable(
+	HarmonyEvaluatedImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency"
+);
+
+HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImportSpecifierDependencyTemplate extends (
+	HarmonyImportSpecifierDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			dependency
+		);
+		const { module, moduleGraph, runtime } = templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const exportsInfo = moduleGraph.getExportsInfo(
+			/** @type {ModuleGraphConnection} */ (connection).module
+		);
+		const ids = dep.getIds(moduleGraph);
+
+		let value;
+
+		const exportsType =
+			/** @type {ModuleGraphConnection} */
+			(connection).module.getExportsType(
+				moduleGraph,
+				/** @type {BuildMeta} */
+				(module.buildMeta).strictHarmonyModule
+			);
+		switch (exportsType) {
+			case "default-with-named": {
+				if (ids[0] === "default") {
+					value =
+						ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "namespace": {
+				value =
+					ids[0] === "__esModule"
+						? ids.length === 1 || undefined
+						: exportsInfo.isExportProvided(ids);
+				break;
+			}
+			case "dynamic": {
+				if (ids[0] !== "default") {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			// default-only could lead to runtime error, when default value is primitive
+		}
+
+		if (typeof value === "boolean") {
+			source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
+		} else {
+			const usedName = exportsInfo.getUsedName(ids, runtime);
+
+			const code = this._getCodeForIds(
+				dep,
+				source,
+				templateContext,
+				ids.slice(0, -1)
+			);
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`${
+					usedName ? JSON.stringify(usedName[usedName.length - 1]) : '""'
+				} in ${code}`
+			);
+		}
+	}
+};
+
+module.exports = HarmonyEvaluatedImportSpecifierDependency;

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -11,28 +11,53 @@ const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDepe
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const {
 	harmonySpecifierTag,
-	getAssertions
+	getAttributes
 } = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
 const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
 module.exports = class HarmonyExportDependencyParserPlugin {
+	/**
+	 * @param {import("../../declarations/WebpackOptions").JavascriptParserOptions} options options
+	 */
 	constructor(options) {
-		this.strictExportPresence = options.strictExportPresence;
+		this.exportPresenceMode =
+			options.reexportExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+				: options.exportsPresence !== undefined
+					? ExportPresenceModes.fromUserOption(options.exportsPresence)
+					: options.strictExportPresence
+						? ExportPresenceModes.ERROR
+						: ExportPresenceModes.AUTO;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
+		const { exportPresenceMode } = this;
 		parser.hooks.export.tap(
 			"HarmonyExportDependencyParserPlugin",
 			statement => {
 				const dep = new HarmonyExportHeaderDependency(
-					statement.declaration && statement.declaration.range,
-					statement.range
+					/** @type {Range | false} */ (
+						statement.declaration && statement.declaration.range
+					),
+					/** @type {Range} */ (statement.range)
+				);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
 				);
-				dep.loc = Object.create(statement.loc);
 				dep.loc.index = -1;
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
@@ -43,16 +68,21 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			(statement, source) => {
 				parser.state.lastHarmonyImportOrder =
 					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency("", statement.range);
-				clearDep.loc = Object.create(statement.loc);
+				const clearDep = new ConstDependency(
+					"",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 				clearDep.loc.index = -1;
 				parser.state.module.addPresentationalDependency(clearDep);
 				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
+					/** @type {string} */ (source),
 					parser.state.lastHarmonyImportOrder,
-					getAssertions(statement)
+					getAttributes(statement)
+				);
+				sideEffectDep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
 				);
-				sideEffectDep.loc = Object.create(statement.loc);
 				sideEffectDep.loc.index = -1;
 				parser.state.current.addDependency(sideEffectDep);
 				return true;
@@ -62,13 +92,12 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			"HarmonyExportDependencyParserPlugin",
 			(statement, expr) => {
 				const isFunctionDeclaration = expr.type === "FunctionDeclaration";
-				const comments = parser.getComments([
-					statement.range[0],
-					expr.range[0]
-				]);
+				const exprRange = /** @type {Range} */ (expr.range);
+				const statementRange = /** @type {Range} */ (statement.range);
+				const comments = parser.getComments([statementRange[0], exprRange[0]]);
 				const dep = new HarmonyExportExpressionDependency(
-					expr.range,
-					statement.range,
+					exprRange,
+					statementRange,
 					comments
 						.map(c => {
 							switch (c.type) {
@@ -83,22 +112,23 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					expr.type.endsWith("Declaration") && expr.id
 						? expr.id.name
 						: isFunctionDeclaration
-						? {
-								id: expr.id ? expr.id.name : undefined,
-								range: [
-									expr.range[0],
-									expr.params.length > 0
-										? expr.params[0].range[0]
-										: expr.body.range[0]
-								],
-								prefix: `${expr.async ? "async " : ""}function${
-									expr.generator ? "*" : ""
-								} `,
-								suffix: `(${expr.params.length > 0 ? "" : ") "}`
-						  }
-						: undefined
+							? {
+									range: [
+										exprRange[0],
+										expr.params.length > 0
+											? /** @type {Range} */ (expr.params[0].range)[0]
+											: /** @type {Range} */ (expr.body.range)[0]
+									],
+									prefix: `${expr.async ? "async " : ""}function${
+										expr.generator ? "*" : ""
+									} `,
+									suffix: `(${expr.params.length > 0 ? "" : ") "}`
+								}
+							: undefined
+				);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
 				);
-				dep.loc = Object.create(statement.loc);
 				dep.loc.index = -1;
 				parser.state.current.addDependency(dep);
 				InnerGraph.addVariableUsage(
@@ -115,28 +145,34 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			"HarmonyExportDependencyParserPlugin",
 			(statement, id, name, idx) => {
 				const settings = parser.getTagData(id, harmonySpecifierTag);
-				let dep;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);
 				InnerGraph.addVariableUsage(parser, id, name);
-				if (settings) {
-					dep = new HarmonyExportImportedSpecifierDependency(
-						settings.source,
-						settings.sourceOrder,
-						settings.ids,
-						name,
-						harmonyNamedExports,
-						null,
-						this.strictExportPresence,
-						null,
-						settings.assertions
-					);
-				} else {
-					dep = new HarmonyExportSpecifierDependency(id, name);
-				}
-				dep.loc = Object.create(statement.loc);
+				const dep = settings
+					? new HarmonyExportImportedSpecifierDependency(
+							settings.source,
+							settings.sourceOrder,
+							settings.ids,
+							name,
+							harmonyNamedExports,
+							null,
+							exportPresenceMode,
+							null,
+							settings.assertions
+						)
+					: new HarmonyExportSpecifierDependency(id, name);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
 				dep.loc.index = idx;
+				const isAsiSafe = !parser.isAsiPosition(
+					/** @type {Range} */
+					(statement.range)[0]
+				);
+				if (!isAsiSafe) {
+					parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				}
 				parser.state.current.addDependency(dep);
 				return true;
 			}
@@ -154,20 +190,29 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						parser.state.harmonyStarExports || new HarmonyStarExportsList();
 				}
 				const dep = new HarmonyExportImportedSpecifierDependency(
-					source,
+					/** @type {string} */ (source),
 					parser.state.lastHarmonyImportOrder,
 					id ? [id] : [],
 					name,
 					harmonyNamedExports,
 					harmonyStarExports && harmonyStarExports.slice(),
-					this.strictExportPresence,
+					exportPresenceMode,
 					harmonyStarExports
 				);
 				if (harmonyStarExports) {
 					harmonyStarExports.push(dep);
 				}
-				dep.loc = Object.create(statement.loc);
+				dep.loc = Object.create(
+					/** @type {DependencyLocation} */ (statement.loc)
+				);
 				dep.loc.index = idx;
+				const isAsiSafe = !parser.isAsiPosition(
+					/** @type {Range} */
+					(statement.range)[0]
+				);
+				if (!isAsiSafe) {
+					parser.setAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				}
 				parser.state.current.addDependency(dep);
 				return true;
 			}

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -8,6 +8,7 @@
 const ConcatenationScope = require("../ConcatenationScope");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
@@ -17,8 +18,17 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class HarmonyExportExpressionDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} rangeStatement range statement
+	 * @param {string} prefix prefix
+	 * @param {string | { range: Range, prefix: string, suffix: string }} [declarationId] declaration id
+	 */
 	constructor(range, rangeStatement, prefix, declarationId) {
 		super();
 		this.range = range;
@@ -54,6 +64,9 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		return false;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -63,6 +76,9 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();
@@ -135,6 +151,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				`/* harmony default export */ ${dep.prefix}`
 			);
 		} else {
+			/** @type {string} */
 			let content;
 			const name = ConcatenationScope.DEFAULT_EXPORT;
 			if (runtimeTemplate.supportsConst()) {
@@ -164,9 +181,9 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				if (used) {
 					runtimeRequirements.add(RuntimeGlobals.exports);
 					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
-						used
-					)}] = `;
+					content = `/* harmony default export */ ${exportsName}${propertyAccess(
+						typeof used === "string" ? [used] : used
+					)} = `;
 				} else {
 					content = `/* unused harmony default export */ var ${name} = `;
 				}
@@ -176,7 +193,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				source.replace(
 					dep.rangeStatement[0],
 					dep.range[0] - 1,
-					content + "(" + dep.prefix
+					`${content}(${dep.prefix}`
 				);
 				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
 				return;

package/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -11,8 +11,15 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class HarmonyExportHeaderDependency extends NullDependency {
+	/**
+	 * @param {Range | false} range range
+	 * @param {Range} rangeStatement range statement
+	 */
 	constructor(range, rangeStatement) {
 		super();
 		this.range = range;
@@ -23,6 +30,9 @@ class HarmonyExportHeaderDependency extends NullDependency {
 		return "harmony export header";
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -30,6 +40,9 @@ class HarmonyExportHeaderDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();