From 9bce51f651aad297ef9eb6df832bfdaf1de05d84 Mon Sep 17 00:00:00 2001
From: WXL <wl_5969728@163.com>
Date: 星期三, 22 四月 2026 14:27:54 +0800
Subject: [PATCH] 青岛推送
---
node_modules/webpack/lib/dependencies/ImportMetaPlugin.js | 177 ++++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 146 insertions(+), 31 deletions(-)
diff --git a/node_modules/webpack/lib/dependencies/ImportMetaPlugin.js b/node_modules/webpack/lib/dependencies/ImportMetaPlugin.js
index da8fe3e..2bbb657 100644
--- a/node_modules/webpack/lib/dependencies/ImportMetaPlugin.js
+++ b/node_modules/webpack/lib/dependencies/ImportMetaPlugin.js
@@ -8,7 +8,7 @@
const { pathToFileURL } = require("url");
const { SyncBailHook } = require("tapable");
const Compilation = require("../Compilation");
-const ModuleDependencyWarning = require("../ModuleDependencyWarning");
+const DefinePlugin = require("../DefinePlugin");
const {
JAVASCRIPT_MODULE_TYPE_AUTO,
JAVASCRIPT_MODULE_TYPE_ESM
@@ -22,11 +22,12 @@
evaluateToString,
toConstantDependency
} = require("../javascript/JavascriptParserHelpers");
-const memoize = require("../util/memoize");
-const propertyAccess = require("../util/propertyAccess");
+const { propertyAccess } = require("../util/property");
const ConstDependency = require("./ConstDependency");
+const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").Identifier} Identifier */
/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
/** @typedef {import("../Compiler")} Compiler */
/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
@@ -37,13 +38,43 @@
/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
/** @typedef {import("./ConstDependency").RawRuntimeRequirements} RawRuntimeRequirements */
-const getCriticalDependencyWarning = memoize(() =>
- require("./CriticalDependencyWarning")
-);
-
const PLUGIN_NAME = "ImportMetaPlugin";
+/** @type {WeakMap<Compilation, { stringify: string, env: Record<string, string> }>} */
+const compilationMetaEnvMap = new WeakMap();
+
/**
+ * Collect import.meta.env definitions from DefinePlugin and build JSON string
+ * @param {Compilation} compilation the compilation
+ * @returns {{ stringify: string, env: Record<string, string> }} env object as JSON string
+ */
+const collectImportMetaEnvDefinitions = (compilation) => {
+ const cached = compilationMetaEnvMap.get(compilation);
+ if (cached) {
+ return cached;
+ }
+
+ const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
+ const definitions = definePluginHooks.definitions.call({});
+ /** @type {Record<string, string>} */
+ const env = {};
+ /** @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}`);
+ env[envKey] = /** @type {string} */ (value);
+ }
+ }
+ const result = { stringify: `{${pairs.join(",")}}`, env };
+ compilationMetaEnvMap.set(compilation, result);
+ return result;
+};
+
+/**
+ * Defines the import meta plugin hooks type used by this module.
* @typedef {object} ImportMetaPluginHooks
* @property {SyncBailHook<[DestructuringAssignmentProperty], string | void>} propertyInDestructuring
*/
@@ -53,6 +84,7 @@
class ImportMetaPlugin {
/**
+ * Returns the attached hooks.
* @param {Compilation} compilation the compilation
* @returns {ImportMetaPluginHooks} the attached hooks
*/
@@ -73,6 +105,7 @@
}
/**
+ * Applies the plugin by registering its hooks on the compiler.
* @param {Compiler} compiler compiler
*/
apply(compiler) {
@@ -81,12 +114,19 @@
(compilation, { normalModuleFactory }) => {
const hooks = ImportMetaPlugin.getCompilationHooks(compilation);
+ compilation.dependencyTemplates.set(
+ ModuleInitFragmentDependency,
+ new ModuleInitFragmentDependency.Template()
+ );
+
/**
+ * Returns file url.
* @param {NormalModule} module module
* @returns {string} file url
*/
const getUrl = (module) => pathToFileURL(module.resource).toString();
/**
+ * Processes the provided parser.
* @param {Parser} parser parser parser
* @param {JavascriptParserOptions} parserOptions parserOptions
* @returns {void}
@@ -119,13 +159,19 @@
JSON.stringify(getUrl(parser.state.module));
const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
/**
+ * Import meta unknown property.
* @param {Members} members members
* @returns {string} error message
*/
- const importMetaUnknownProperty = (members) =>
- `${Template.toNormalComment(
+ const importMetaUnknownProperty = (members) => {
+ if (importMeta === "preserve-unknown") {
+ return `import.meta${propertyAccess(members, 0)}`;
+ }
+ return `${Template.toNormalComment(
`unsupported import.meta.${members.join(".")}`
)} undefined${propertyAccess(members, 1)}`;
+ };
+
parser.hooks.typeof
.for("import.meta")
.tap(
@@ -141,37 +187,47 @@
parser.hooks.expression
.for("import.meta")
.tap(PLUGIN_NAME, (metaProperty) => {
+ /** @type {RawRuntimeRequirements} */
+ const runtimeRequirements = [];
+ const moduleArgument = parser.state.module.moduleArgument;
+
const referencedPropertiesInDestructuring =
parser.destructuringAssignmentPropertiesFor(metaProperty);
if (!referencedPropertiesInDestructuring) {
- const CriticalDependencyWarning =
- getCriticalDependencyWarning();
- parser.state.module.addWarning(
- new ModuleDependencyWarning(
- parser.state.module,
- new CriticalDependencyWarning(
- "'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)
- )
+ const varName = "__webpack_import_meta__";
+ const { stringify: envStringify } =
+ collectImportMetaEnvDefinitions(compilation);
+ const knownProps =
+ `{url: ${importMetaUrl()}, ` +
+ `webpack: ${importMetaWebpackVersion()}, ` +
+ `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument}, ` +
+ `env: ${envStringify}}`;
+ const initCode =
+ importMeta === "preserve-unknown"
+ ? `var ${varName} = Object.assign(import.meta, ${knownProps});\n`
+ : `var ${varName} = ${knownProps};\n`;
+ const initDep = new ModuleInitFragmentDependency(
+ initCode,
+ [
+ RuntimeGlobals.moduleCache,
+ RuntimeGlobals.entryModuleId,
+ RuntimeGlobals.module
+ ],
+ varName
);
+ initDep.loc = /** @type {DependencyLocation} */ (
+ metaProperty.loc
+ );
+ parser.state.module.addPresentationalDependency(initDep);
const dep = new ConstDependency(
- `${
- parser.isAsiPosition(
- /** @type {Range} */ (metaProperty.range)[0]
- )
- ? ";"
- : ""
- }({})`,
- /** @type {Range} */ (metaProperty.range)
+ varName,
+ /** @type {Range} */ (metaProperty.range),
+ runtimeRequirements
);
dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
parser.state.module.addPresentationalDependency(dep);
return true;
}
-
- /** @type {RawRuntimeRequirements} */
- const runtimeRequirements = [];
let str = "";
for (const prop of referencedPropertiesInDestructuring) {
@@ -190,12 +246,15 @@
str += `webpack: ${importMetaWebpackVersion()},`;
break;
case "main":
- str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module},`;
+ str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument},`;
runtimeRequirements.push(
RuntimeGlobals.moduleCache,
RuntimeGlobals.entryModuleId,
RuntimeGlobals.module
);
+ break;
+ case "env":
+ str += `env: ${collectImportMetaEnvDefinitions(compilation).stringify},`;
break;
default:
str += `[${JSON.stringify(
@@ -294,10 +353,65 @@
.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.expressionMemberChain
+ .for("import.meta")
+ .tap(PLUGIN_NAME, (expr, members) => {
+ if (members[0] === "env" && members[1]) {
+ const name = members[1];
+ const { env } = collectImportMetaEnvDefinitions(compilation);
+ if (!Object.prototype.hasOwnProperty.call(env, name)) {
+ const dep = new ConstDependency(
+ "undefined",
+ /** @type {Range} */ (expr.range)
+ );
+ dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+ parser.state.module.addPresentationalDependency(dep);
+ return true;
+ }
+ }
+ });
+ parser.hooks.expression
+ .for("import.meta.env")
+ .tap(PLUGIN_NAME, (expr) => {
+ const { stringify } =
+ collectImportMetaEnvDefinitions(compilation);
+
+ const dep = new ConstDependency(
+ stringify,
+ /** @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) => {
+ // unknown import.meta properties should be determined at runtime
+ if (importMeta === "preserve-unknown") {
+ 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
@@ -316,6 +430,7 @@
parser.state.module.addPresentationalDependency(dep);
return true;
});
+
parser.hooks.evaluate
.for("MemberExpression")
.tap(PLUGIN_NAME, (expression) => {
--
Gitblit v1.9.3