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

package/lib/dependencies/ImportMetaGlobDependencyParserPlugin.js

@@ -11,9 +11,8 @@ const {
 const ImportMetaGlobDependency = require("./ImportMetaGlobDependency");
 const { parseImportMetaGlobCall } = require("./ImportMetaGlobHelpers");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @import { CallExpression } from "estree" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "ImportMetaGlobDependencyParserPlugin";
 

package/lib/dependencies/ImportMetaGlobHelpers.js

@@ -5,8 +5,10 @@
 
 "use strict";
 
+/** @import UnsupportedFeatureWarning from "../errors/UnsupportedFeatureWarning" */
+
 const path = require("path");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+
 const WebpackError = require("../errors/WebpackError");
 const {
 	commonGlobBaseDir,
@@ -18,29 +20,24 @@ const {
 	normalizePathSeparatorsForPath,
 	resolveContextModuleGlobPattern
 } = require("../util/globUtils");
+const { relativePathToRequest } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
 
+/** @import { ContextModuleOptions } from "../ContextModule" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { RawReferencedExports, DependencyLocation } from "../Dependency" */
 /**
- * @param {string} relativePath relative path
- * @returns {string} request
+ * @import {
+ * 	CallExpression,
+ * 	Expression,
+ * 	ObjectExpression,
+ * 	Property
+ * } from "estree"
  */
-const relativePathToRequest = (relativePath) => {
-	if (relativePath === "") return "./.";
-	if (relativePath === "..") return "../.";
-	if (relativePath.startsWith("../")) return relativePath;
-	return `./${relativePath}`;
-};
-
-/** @typedef {import("../ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("./ImportMetaGlobDependency").ImportMetaGlobDependencyOptions} ImportMetaGlobDependencyOptions */
-
 /**
  * @typedef {object} ParsedImportMetaGlobOptions
  * @property {string[]} patterns patterns
@@ -77,7 +74,7 @@ const createImportMetaGlobError = (msg, loc) => {
  * @returns {UnsupportedFeatureWarning} warning
  */
 const createImportMetaGlobWarning = (msg, loc) =>
-	new UnsupportedFeatureWarning(msg, loc);
+	new (getUnsupportedFeatureWarning())(msg, loc);
 
 /**
  * @param {Expression} expr expression

package/lib/dependencies/ImportMetaHotAcceptDependency.js

@@ -9,7 +9,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
 
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { Range } from "../javascript/JavascriptParser" */
 
 class ImportMetaHotAcceptDependency extends ModuleDependency {
 	/**

package/lib/dependencies/ImportMetaHotDeclineDependency.js

@@ -9,7 +9,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
 
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { Range } from "../javascript/JavascriptParser" */
 
 class ImportMetaHotDeclineDependency extends ModuleDependency {
 	/**

package/lib/dependencies/ImportMetaPlugin.js

@@ -7,7 +7,7 @@
 
 const { pathToFileURL } = require("url");
 const { SyncBailHook } = require("tapable");
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 const DefinePlugin = require("../DefinePlugin");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -25,6 +25,7 @@ const {
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
+const BuildTimeConstDependency = require("./BuildTimeConstDependency");
 const ConstDependency = require("./ConstDependency");
 const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
@@ -36,23 +37,37 @@ const WEBPACK_VERSION = Number.parseInt(
 	10
 );
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").Super} Super */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DefinePlugin").MergedDefinitionNode} MergedDefinitionNode */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module").ValueCacheVersion} ValueCacheVersion */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
-/** @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 */
+/**
+ * @import {
+ * 	MemberExpression,
+ * 	Identifier,
+ * 	CallExpression,
+ * 	Expression,
+ * 	Super
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { MergedDefinitionNode } from "../DefinePlugin" */
+/** @import { ValueCacheVersion } from "../Module" */
+/** @import NormalModule, { NormalModuleBuildInfo } from "../NormalModule" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
+/**
+ * @import Parser, {
+ * 	Range,
+ * 	Members,
+ * 	DestructuringAssignmentProperty
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import { RawRuntimeRequirements } from "./NullDependency" */
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
@@ -138,6 +153,18 @@ const isImportMetaFieldEnabled = (importMeta, field) => {
 	);
 };
 
+/**
+ * Renders the `import.meta.main` comparison and bails out of scope hoisting.
+ * @param {Parser} parser the parser
+ * @returns {string} the comparison expression
+ */
+const renderImportMetaMain = (parser) => {
+	const currentModule = parser.state.module;
+	/** @type {JavascriptModuleBuildInfo} */
+	(currentModule.buildInfo).moduleConcatenationBailout = IMPORT_META_MAIN;
+	return `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${currentModule.moduleArgument}`;
+};
+
 /**
  * Checks whether the callee is the `import.meta.resolve` member.
  * @param {Expression | Super} callee call callee
@@ -230,6 +257,10 @@ class ImportMetaPlugin {
 					ImportMetaResolveDependency,
 					new ImportMetaResolveDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					BuildTimeConstDependency,
+					new BuildTimeConstDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -371,6 +402,15 @@ class ImportMetaPlugin {
 						`[${JSON.stringify(field)}]: ${importMetaUnknownProperty([
 							field
 						])},`;
+					/**
+					 * Import meta runtime property for build-time execution.
+					 * @param {string} field field name
+					 * @returns {string} generated property
+					 */
+					const importMetaBuildTimeProperty = (field) =>
+						`[${JSON.stringify(field)}]: ${Template.toNormalComment(
+							`unsupported import.meta.${field}`
+						)} undefined,`;
 
 					parser.hooks.typeof
 						.for(IMPORT_META)
@@ -398,7 +438,6 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, (metaProperty) => {
 							/** @type {RawRuntimeRequirements} */
 							const runtimeRequirements = [];
-							const moduleArgument = parser.state.module.moduleArgument;
 
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
@@ -412,9 +451,7 @@ class ImportMetaPlugin {
 									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "main")) {
-									knownProps.push(
-										`main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument}`
-									);
+									knownProps.push(`main: ${renderImportMetaMain(parser)}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "env")) {
 									addDefinitionValueDependencies();
@@ -431,11 +468,14 @@ class ImportMetaPlugin {
 										)}`
 									);
 								}
+								const plainInitCode = `var ${varName} = {${knownProps.join(
+									", "
+								)}};\n`;
 								const initCode = preserveUnknown(importMeta)
 									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
 											", "
 										)}});\n`
-									: `var ${varName} = {${knownProps.join(", ")}};\n`;
+									: plainInitCode;
 								/** @type {RawRuntimeRequirements} */
 								const initRuntimeRequirements = [
 									RuntimeGlobals.moduleCache,
@@ -450,7 +490,9 @@ class ImportMetaPlugin {
 								const initDep = new ModuleInitFragmentDependency(
 									initCode,
 									initRuntimeRequirements,
-									varName
+									varName,
+									// native `import.meta` does not parse in the build-time vm
+									initCode === plainInitCode ? undefined : plainInitCode
 								);
 								initDep.loc = parser.getLocation(metaProperty);
 								parser.state.module.addPresentationalDependency(initDep);
@@ -465,6 +507,24 @@ class ImportMetaPlugin {
 							}
 
 							let str = "";
+							let strBuildTime = "";
+							/**
+							 * Appends a property shared by both variants.
+							 * @param {string} code generated property
+							 */
+							const append = (code) => {
+								str += code;
+								strBuildTime += code;
+							};
+							/**
+							 * Appends a property reading native `import.meta`, which
+							 * does not parse in the build-time vm.
+							 * @param {string} field field name
+							 */
+							const appendRuntimeProperty = (field) => {
+								str += importMetaRuntimeProperty(field);
+								strBuildTime += importMetaBuildTimeProperty(field);
+							};
 							for (const prop of referencedPropertiesInDestructuring) {
 								const fieldEnabled = isImportMetaFieldEnabled(
 									importMeta,
@@ -475,51 +535,59 @@ class ImportMetaPlugin {
 									: undefined;
 
 								if (value) {
-									str += value;
+									append(value);
 									continue;
 								}
 
 								switch (prop.id) {
 									case "url":
-										str += fieldEnabled
-											? `url: ${importMetaUrl()},`
-											: importMetaRuntimeProperty(prop.id);
+										if (fieldEnabled) {
+											append(`url: ${importMetaUrl()},`);
+										} else {
+											appendRuntimeProperty(prop.id);
+										}
 										break;
 									case "webpack":
-										str += fieldEnabled
-											? `webpack: ${importMetaWebpackVersion()},`
-											: importMetaRuntimeProperty(prop.id);
+										if (fieldEnabled) {
+											append(`webpack: ${importMetaWebpackVersion()},`);
+										} else {
+											appendRuntimeProperty(prop.id);
+										}
 										break;
 									case "main":
 										if (fieldEnabled) {
-											str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument},`;
+											append(`main: ${renderImportMetaMain(parser)},`);
 											runtimeRequirements.push(
 												RuntimeGlobals.moduleCache,
 												RuntimeGlobals.entryModuleId,
 												RuntimeGlobals.module
 											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									case "env":
 										if (fieldEnabled) {
 											addDefinitionValueDependencies();
-											str += `env: ${renderDefinition(envNode, IMPORT_META_ENV)},`;
+											append(
+												`env: ${renderDefinition(envNode, IMPORT_META_ENV)},`
+											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									default: {
 										const node = customProps.get(prop.id);
 										if (node !== undefined) {
 											addDefinitionValueDependencies();
-											str += `${DefinePlugin.toPropertyKey(prop.id)}: ${renderDefinition(
-												node,
-												`${IMPORT_META}.${prop.id}`
-											)},`;
+											append(
+												`${DefinePlugin.toPropertyKey(prop.id)}: ${renderDefinition(
+													node,
+													`${IMPORT_META}.${prop.id}`
+												)},`
+											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									}
@@ -531,11 +599,19 @@ class ImportMetaPlugin {
 							if (codeRequirements) {
 								runtimeRequirements.push(...codeRequirements);
 							}
-							const dep = new ConstDependency(
-								strCode,
-								/** @type {Range} */ (metaProperty.range),
-								runtimeRequirements
-							);
+							const dep =
+								strBuildTime === str
+									? new ConstDependency(
+											strCode,
+											/** @type {Range} */ (metaProperty.range),
+											runtimeRequirements
+										)
+									: new BuildTimeConstDependency(
+											strCode,
+											`({${strBuildTime}})`,
+											/** @type {Range} */ (metaProperty.range),
+											runtimeRequirements
+										);
 							dep.loc = parser.getLocation(metaProperty);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
@@ -664,17 +740,12 @@ class ImportMetaPlugin {
 					if (isImportMetaFieldEnabled(importMeta, "main")) {
 						parser.hooks.expression
 							.for(IMPORT_META_MAIN)
-							.tap(
-								PLUGIN_NAME,
-								toConstantDependency(
-									parser,
-									`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
-									[
-										RuntimeGlobals.moduleCache,
-										RuntimeGlobals.entryModuleId,
-										RuntimeGlobals.module
-									]
-								)
+							.tap(PLUGIN_NAME, (expr) =>
+								toConstantDependency(parser, renderImportMetaMain(parser), [
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								])(expr)
 							);
 						parser.hooks.typeof
 							.for(IMPORT_META_MAIN)
@@ -752,15 +823,6 @@ class ImportMetaPlugin {
 					parser.hooks.unhandledExpressionMemberChain
 						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (expr, members) => {
-							// unknown import.meta properties should be determined at runtime
-							if (
-								preserveUnknown(importMeta) ||
-								(IMPORT_META_FIELDS.has(members[0]) &&
-									!isImportMetaFieldEnabled(importMeta, members[0]))
-							) {
-								return true;
-							}
-
 							// keep import.meta.env unknown property
 							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
 							// `dirname` and `filename` logic in NodeStuffPlugin
@@ -771,6 +833,26 @@ class ImportMetaPlugin {
 							) {
 								return true;
 							}
+
+							// unknown import.meta properties should be determined at runtime
+							if (
+								preserveUnknown(importMeta) ||
+								(IMPORT_META_FIELDS.has(members[0]) &&
+									!isImportMetaFieldEnabled(importMeta, members[0]))
+							) {
+								// keep the native access verbatim for emitted output, but
+								// native `import.meta` does not parse in the build-time vm
+								const dep = new BuildTimeConstDependency(
+									`${IMPORT_META}${propertyAccess(members, 0)}`,
+									`${Template.toNormalComment(
+										`unsupported import.meta.${members.join(".")}`
+									)} undefined${propertyAccess(members, 1)}`,
+									/** @type {Range} */ (expr.range)
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)
@@ -834,10 +916,11 @@ ImportMetaPlugin.getCompilationHooks = createHooksRegistry(
 		})
 );
 
-module.exports = ImportMetaPlugin;
-module.exports.IMPORT_META_DIRNAME = IMPORT_META_DIRNAME;
-module.exports.IMPORT_META_FILENAME = IMPORT_META_FILENAME;
-module.exports.IMPORT_META_NAMES = IMPORT_META_NAMES;
-module.exports.IMPORT_META_STAGE_ESM_DETECTION =
+ImportMetaPlugin.IMPORT_META_DIRNAME = IMPORT_META_DIRNAME;
+ImportMetaPlugin.IMPORT_META_FILENAME = IMPORT_META_FILENAME;
+ImportMetaPlugin.IMPORT_META_NAMES = IMPORT_META_NAMES;
+ImportMetaPlugin.IMPORT_META_STAGE_ESM_DETECTION =
 	IMPORT_META_STAGE_ESM_DETECTION;
-module.exports.isImportMetaFieldEnabled = isImportMetaFieldEnabled;
+ImportMetaPlugin.isImportMetaFieldEnabled = isImportMetaFieldEnabled;
+
+module.exports = ImportMetaPlugin;

package/lib/dependencies/ImportMetaResolveDependency.js

@@ -10,10 +10,9 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const URLDependency = require("./URLDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 // `import.meta.resolve(specifier)` is the string form of
 // `new URL(specifier, import.meta.url)`, so it reuses the URL asset pipeline