webpack 5.97.1 → 5.104.1

package/lib/dependencies/ImportMetaPlugin.js

@@ -6,18 +6,22 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const { SyncBailHook } = require("tapable");
+const Compilation = require("../Compilation");
+const DefinePlugin = require("../DefinePlugin");
 const ModuleDependencyWarning = require("../ModuleDependencyWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const {
 	evaluateToIdentifier,
-	toConstantDependency,
+	evaluateToNumber,
 	evaluateToString,
-	evaluateToNumber
+	toConstantDependency
 } = require("../javascript/JavascriptParserHelpers");
 const memoize = require("../util/memoize");
 const propertyAccess = require("../util/propertyAccess");
@@ -30,6 +34,9 @@ const ConstDependency = require("./ConstDependency");
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("./ConstDependency").RawRuntimeRequirements} RawRuntimeRequirements */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
@@ -37,7 +44,60 @@ const getCriticalDependencyWarning = memoize(() =>
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
+/**
+ * Collect import.meta.env definitions from DefinePlugin and build JSON string
+ * @param {Compilation} compilation the compilation
+ * @returns {string} env object as JSON string
+ */
+const collectImportMetaEnvDefinitions = (compilation) => {
+	const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
+	const definitions = definePluginHooks.definitions.call({});
+	if (!definitions) {
+		return "{}";
+	}
+
+	/** @type {string[]} */
+	const pairs = [];
+	for (const key of Object.keys(definitions)) {
+		if (key.startsWith("import.meta.env.")) {
+			const envKey = key.slice("import.meta.env.".length);
+			const value = definitions[key];
+			pairs.push(`${JSON.stringify(envKey)}:${value}`);
+		}
+	}
+
+	return `{${pairs.join(",")}}`;
+};
+
+/**
+ * @typedef {object} ImportMetaPluginHooks
+ * @property {SyncBailHook<[DestructuringAssignmentProperty], string | void>} propertyInDestructuring
+ */
+
+/** @type {WeakMap<Compilation, ImportMetaPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class ImportMetaPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ImportMetaPluginHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				propertyInDestructuring: new SyncBailHook(["property"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
@@ -45,11 +105,13 @@ class ImportMetaPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const hooks = ImportMetaPlugin.getCompilationHooks(compilation);
+
 				/**
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
 				 */
-				const getUrl = module => pathToFileURL(module.resource).toString();
+				const getUrl = (module) => pathToFileURL(module.resource).toString();
 				/**
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
@@ -62,7 +124,7 @@ class ImportMetaPlugin {
 
 						parser.hooks.expression
 							.for("import.meta")
-							.tap(PLUGIN_NAME, metaProperty => {
+							.tap(PLUGIN_NAME, (metaProperty) => {
 								const dep = new ConstDependency(
 									/** @type {string} */ (importMetaName),
 									/** @type {Range} */ (metaProperty.range)
@@ -83,10 +145,10 @@ class ImportMetaPlugin {
 						JSON.stringify(getUrl(parser.state.module));
 					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
 					/**
-					 * @param {string[]} members members
+					 * @param {Members} members members
 					 * @returns {string} error message
 					 */
-					const importMetaUnknownProperty = members =>
+					const importMetaUnknownProperty = (members) =>
 						`${Template.toNormalComment(
 							`unsupported import.meta.${members.join(".")}`
 						)} undefined${propertyAccess(members, 1)}`;
@@ -96,9 +158,15 @@ class ImportMetaPlugin {
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
+					parser.hooks.collectDestructuringAssignmentProperties.tap(
+						PLUGIN_NAME,
+						(expr) => {
+							if (expr.type === "MetaProperty") return true;
+						}
+					);
 					parser.hooks.expression
 						.for("import.meta")
-						.tap(PLUGIN_NAME, metaProperty => {
+						.tap(PLUGIN_NAME, (metaProperty) => {
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
 							if (!referencedPropertiesInDestructuring) {
@@ -108,7 +176,7 @@ class ImportMetaPlugin {
 									new ModuleDependencyWarning(
 										parser.state.module,
 										new CriticalDependencyWarning(
-											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
+											"'import.meta' cannot be used as a standalone expression. For static analysis, its properties must be accessed directly (e.g., 'import.meta.url') or through destructuring."
 										),
 										/** @type {DependencyLocation} */ (metaProperty.loc)
 									)
@@ -128,25 +196,44 @@ class ImportMetaPlugin {
 								return true;
 							}
 
+							/** @type {RawRuntimeRequirements} */
+							const runtimeRequirements = [];
+
 							let str = "";
-							for (const { id: prop } of referencedPropertiesInDestructuring) {
-								switch (prop) {
+							for (const prop of referencedPropertiesInDestructuring) {
+								const value = hooks.propertyInDestructuring.call(prop);
+
+								if (value) {
+									str += value;
+									continue;
+								}
+
+								switch (prop.id) {
 									case "url":
 										str += `url: ${importMetaUrl()},`;
 										break;
 									case "webpack":
 										str += `webpack: ${importMetaWebpackVersion()},`;
 										break;
+									case "main":
+										str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module},`;
+										runtimeRequirements.push(
+											RuntimeGlobals.moduleCache,
+											RuntimeGlobals.entryModuleId,
+											RuntimeGlobals.module
+										);
+										break;
 									default:
 										str += `[${JSON.stringify(
-											prop
-										)}]: ${importMetaUnknownProperty([prop])},`;
+											prop.id
+										)}]: ${importMetaUnknownProperty([prop.id])},`;
 										break;
 								}
 							}
 							const dep = new ConstDependency(
 								`({${str}})`,
-								/** @type {Range} */ (metaProperty.range)
+								/** @type {Range} */ (metaProperty.range),
+								runtimeRequirements
 							);
 							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
@@ -169,7 +256,7 @@ class ImportMetaPlugin {
 						);
 					parser.hooks.expression
 						.for("import.meta.url")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							const dep = new ConstDependency(
 								importMetaUrl(),
 								/** @type {Range} */ (expr.range)
@@ -183,24 +270,24 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.url")
-						.tap(PLUGIN_NAME, expr =>
+						.tap(PLUGIN_NAME, (expr) =>
 							new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
 								.setRange(/** @type {Range} */ (expr.range))
 						);
 
 					// import.meta.webpack
-					parser.hooks.typeof
+					parser.hooks.expression
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("number"))
+							toConstantDependency(parser, importMetaWebpackVersion())
 						);
-					parser.hooks.expression
+					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, importMetaWebpackVersion())
+							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("import.meta.webpack")
@@ -209,10 +296,75 @@ class ImportMetaPlugin {
 						.for("import.meta.webpack")
 						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
+					parser.hooks.expression
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
+								[
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								]
+							)
+						);
+					parser.hooks.typeof
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("boolean"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.main")
+						.tap(PLUGIN_NAME, evaluateToString("boolean"));
+
+					// import.meta.env
+					parser.hooks.typeof
+						.for("import.meta.env")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.expression
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, (expr) => {
+							const envCode = collectImportMetaEnvDefinitions(compilation);
+							const dep = new ConstDependency(
+								envCode,
+								/** @type {Range} */ (expr.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, evaluateToString("object"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, (expr) =>
+							new BasicEvaluatedExpression()
+								.setTruthy()
+								.setSideEffects(false)
+								.setRange(/** @type {Range} */ (expr.range))
+						);
+
 					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {
+							// keep import.meta.env unknown property
+							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
+							// `dirname` and `filename` logic in NodeStuffPlugin
+							if (
+								members[0] === "env" ||
+								members[0] === "dirname" ||
+								members[0] === "filename"
+							) {
+								return true;
+							}
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)
@@ -223,7 +375,7 @@ class ImportMetaPlugin {
 						});
 					parser.hooks.evaluate
 						.for("MemberExpression")
-						.tap(PLUGIN_NAME, expression => {
+						.tap(PLUGIN_NAME, (expression) => {
 							const expr = /** @type {MemberExpression} */ (expression);
 							if (
 								expr.object.type === "MetaProperty" &&