webpack 5.59.0 → 5.94.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -7,6 +7,10 @@
 
 const { pathToFileURL } = require("url");
 const ModuleDependencyWarning = require("../ModuleDependencyWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const Template = require("../Template");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const {
@@ -20,141 +24,206 @@ const propertyAccess = require("../util/propertyAccess");
 const ConstDependency = require("./ConstDependency");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
 );
 
+const PLUGIN_NAME = "ImportMetaPlugin";
+
 class ImportMetaPlugin {
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"ImportMetaPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/**
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
 				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource).toString();
-				};
+				const getUrl = module => pathToFileURL(module.resource).toString();
 				/**
-				 * @param {Parser} parser parser
-				 * @param {Object} parserOptions parserOptions
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}
 				 */
-				const parserHandler = (parser, parserOptions) => {
-					/// import.meta direct ///
+				const parserHandler = (parser, { importMeta }) => {
+					if (importMeta === false) {
+						const { importMetaName } = compilation.outputOptions;
+						if (importMetaName === "import.meta") return;
+
+						parser.hooks.expression
+							.for("import.meta")
+							.tap(PLUGIN_NAME, metaProperty => {
+								const dep = new ConstDependency(
+									/** @type {string} */ (importMetaName),
+									/** @type {Range} */ (metaProperty.range)
+								);
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						return;
+					}
+
+					// import.meta direct
+					const webpackVersion = Number.parseInt(
+						require("../../package.json").version,
+						10
+					);
+					const importMetaUrl = () =>
+						JSON.stringify(getUrl(parser.state.module));
+					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					/**
+					 * @param {string[]} members members
+					 * @returns {string} error message
+					 */
+					const importMetaUnknownProperty = members =>
+						`${Template.toNormalComment(
+							`unsupported import.meta.${members.join(".")}`
+						)} undefined${propertyAccess(members, 1)}`;
 					parser.hooks.typeof
 						.for("import.meta")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
 					parser.hooks.expression
 						.for("import.meta")
-						.tap("ImportMetaPlugin", metaProperty => {
-							const CriticalDependencyWarning = getCriticalDependencyWarning();
-							parser.state.module.addWarning(
-								new ModuleDependencyWarning(
-									parser.state.module,
-									new CriticalDependencyWarning(
-										"Accessing import.meta directly is unsupported (only property access is supported)"
-									),
-									metaProperty.loc
-								)
-							);
+						.tap(PLUGIN_NAME, metaProperty => {
+							const referencedPropertiesInDestructuring =
+								parser.destructuringAssignmentPropertiesFor(metaProperty);
+							if (!referencedPropertiesInDestructuring) {
+								const CriticalDependencyWarning =
+									getCriticalDependencyWarning();
+								parser.state.module.addWarning(
+									new ModuleDependencyWarning(
+										parser.state.module,
+										new CriticalDependencyWarning(
+											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
+										),
+										/** @type {DependencyLocation} */ (metaProperty.loc)
+									)
+								);
+								const dep = new ConstDependency(
+									`${
+										parser.isAsiPosition(
+											/** @type {Range} */ (metaProperty.range)[0]
+										)
+											? ";"
+											: ""
+									}({})`,
+									/** @type {Range} */ (metaProperty.range)
+								);
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
+
+							let str = "";
+							for (const { id: prop } of referencedPropertiesInDestructuring) {
+								switch (prop) {
+									case "url":
+										str += `url: ${importMetaUrl()},`;
+										break;
+									case "webpack":
+										str += `webpack: ${importMetaWebpackVersion()},`;
+										break;
+									default:
+										str += `[${JSON.stringify(
+											prop
+										)}]: ${importMetaUnknownProperty([prop])},`;
+										break;
+								}
+							}
 							const dep = new ConstDependency(
-								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
-								metaProperty.range
+								`({${str}})`,
+								/** @type {Range} */ (metaProperty.range)
 							);
-							dep.loc = metaProperty.loc;
+							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluateTypeof
 						.for("import.meta")
-						.tap("ImportMetaPlugin", evaluateToString("object"));
+						.tap(PLUGIN_NAME, evaluateToString("object"));
 					parser.hooks.evaluateIdentifier.for("import.meta").tap(
-						"ImportMetaPlugin",
+						PLUGIN_NAME,
 						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
 					);
 
-					/// import.meta.url ///
+					// import.meta.url
 					parser.hooks.typeof
 						.for("import.meta.url")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("string"))
 						);
 					parser.hooks.expression
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							const dep = new ConstDependency(
-								JSON.stringify(getUrl(parser.state.module)),
-								expr.range
+								importMetaUrl(),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluateTypeof
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", evaluateToString("string"));
+						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
-							return new BasicEvaluatedExpression()
+						.tap(PLUGIN_NAME, expr =>
+							new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
-								.setRange(expr.range);
-						});
+								.setRange(/** @type {Range} */ (expr.range))
+						);
 
-					/// import.meta.webpack ///
-					const webpackVersion = parseInt(
-						require("../../package.json").version,
-						10
-					);
+					// import.meta.webpack
 					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.expression
 						.for("import.meta.webpack")
 						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify(webpackVersion))
+							PLUGIN_NAME,
+							toConstantDependency(parser, importMetaWebpackVersion())
 						);
 					parser.hooks.evaluateTypeof
 						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToString("number"));
+						.tap(PLUGIN_NAME, evaluateToString("number"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
+						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
-					/// Unknown properties ///
+					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
-						.tap("ImportMetaPlugin", (expr, members) => {
+						.tap(PLUGIN_NAME, (expr, members) => {
 							const dep = new ConstDependency(
-								`${Template.toNormalComment(
-									"unsupported import.meta." + members.join(".")
-								)} undefined${propertyAccess(members, 1)}`,
-								expr.range
+								importMetaUnknownProperty(members),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluate
 						.for("MemberExpression")
-						.tap("ImportMetaPlugin", expression => {
+						.tap(PLUGIN_NAME, expression => {
 							const expr = /** @type {MemberExpression} */ (expression);
 							if (
 								expr.object.type === "MetaProperty" &&
@@ -165,17 +234,17 @@ class ImportMetaPlugin {
 							) {
 								return new BasicEvaluatedExpression()
 									.setUndefined()
-									.setRange(expr.range);
+									.setRange(/** @type {Range} */ (expr.range));
 							}
 						});
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportMetaPlugin", parserHandler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserHandler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportMetaPlugin", parserHandler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserHandler);
 			}
 		);
 	}

package/lib/dependencies/ImportParserPlugin.js

@@ -9,26 +9,46 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const { getAttributes } = require("./HarmonyImportDependencyParserPlugin");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
+/** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class ImportParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
+		/**
+		 * @template T
+		 * @param {Iterable<T>} enumerable enumerable
+		 * @returns {T[][]} array of array
+		 */
+		const exportsFromEnumerable = enumerable =>
+			Array.from(enumerable, e => [e]);
 		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
 			const param = parser.evaluateExpression(expr.source);
 
 			let chunkName = null;
-			/** @type {ContextMode} */
-			let mode = "lazy";
+			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
 			let include = null;
 			let exclude = null;
 			/** @type {string[][] | null} */
@@ -36,8 +56,28 @@ class ImportParserPlugin {
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
 
+			const {
+				dynamicImportPreload,
+				dynamicImportPrefetch,
+				dynamicImportFetchPriority
+			} = this.options;
+			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+				groupOptions.preloadOrder =
+					dynamicImportPreload === true ? 0 : dynamicImportPreload;
+			if (
+				dynamicImportPrefetch !== undefined &&
+				dynamicImportPrefetch !== false
+			)
+				groupOptions.prefetchOrder =
+					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+			if (
+				dynamicImportFetchPriority !== undefined &&
+				dynamicImportFetchPriority !== false
+			)
+				groupOptions.fetchPriority = dynamicImportFetchPriority;
+
 			const { options: importOptions, errors: commentErrors } =
-				parser.parseCommentOptions(expr.range);
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 			if (commentErrors) {
 				for (const e of commentErrors) {
@@ -57,14 +97,12 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
-					} else {
+					} else if (importOptions.webpackIgnore) {
 						// Do not instrument `import()` if `webpackIgnore` is `true`
-						if (importOptions.webpackIgnore) {
-							return false;
-						}
+						return false;
 					}
 				}
 				if (importOptions.webpackChunkName !== undefined) {
@@ -72,7 +110,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -84,7 +122,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -100,7 +138,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -114,7 +152,22 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackFetchPriority !== undefined) {
+					if (
+						typeof importOptions.webpackFetchPriority === "string" &&
+						["high", "low", "auto"].includes(importOptions.webpackFetchPriority)
+					) {
+						groupOptions.fetchPriority = importOptions.webpackFetchPriority;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -122,31 +175,31 @@ class ImportParserPlugin {
 				if (importOptions.webpackInclude !== undefined) {
 					if (
 						!importOptions.webpackInclude ||
-						importOptions.webpackInclude.constructor.name !== "RegExp"
+						!(importOptions.webpackInclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
-						include = new RegExp(importOptions.webpackInclude);
+						include = importOptions.webpackInclude;
 					}
 				}
 				if (importOptions.webpackExclude !== undefined) {
 					if (
 						!importOptions.webpackExclude ||
-						importOptions.webpackExclude.constructor.name !== "RegExp"
+						!(importOptions.webpackExclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
-						exclude = new RegExp(importOptions.webpackExclude);
+						exclude = importOptions.webpackExclude;
 					}
 				}
 				if (importOptions.webpackExports !== undefined) {
@@ -154,7 +207,7 @@ class ImportParserPlugin {
 						!(
 							typeof importOptions.webpackExports === "string" ||
 							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
+								/** @type {string[]} */ (importOptions.webpackExports).every(
 									item => typeof item === "string"
 								))
 						)
@@ -162,41 +215,65 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
+					} else if (typeof importOptions.webpackExports === "string") {
+						exports = [[importOptions.webpackExports]];
 					} else {
-						if (typeof importOptions.webpackExports === "string") {
-							exports = [[importOptions.webpackExports]];
-						} else {
-							exports = Array.from(importOptions.webpackExports, e => [e]);
-						}
+						exports = exportsFromEnumerable(importOptions.webpackExports);
 					}
 				}
 			}
 
-			if (param.isString()) {
-				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
+			if (
+				mode !== "lazy" &&
+				mode !== "lazy-once" &&
+				mode !== "eager" &&
+				mode !== "weak"
+			) {
+				parser.state.module.addWarning(
+					new UnsupportedFeatureWarning(
+						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+						/** @type {DependencyLocation} */ (expr.loc)
+					)
+				);
+				mode = "lazy";
+			}
+
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			if (referencedPropertiesInDestructuring) {
+				if (exports) {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
+							"`webpackExports` could not be used with destructuring assignment.",
+							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
 				}
+				exports = exportsFromEnumerable(
+					[...referencedPropertiesInDestructuring].map(({ id }) => id)
+				);
+			}
+
+			if (param.isString()) {
+				const attributes = getAttributes(expr);
 
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
-						param.string,
-						expr.range,
-						exports
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
 					);
 					parser.state.current.addDependency(dep);
 				} else if (mode === "weak") {
 					const dep = new ImportWeakDependency(
-						param.string,
-						expr.range,
-						exports
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
 					);
 					parser.state.current.addDependency(dep);
 				} else {
@@ -205,61 +282,54 @@ class ImportParserPlugin {
 							...groupOptions,
 							name: chunkName
 						},
-						expr.loc,
+						/** @type {DependencyLocation} */ (expr.loc),
 						param.string
 					);
-					const dep = new ImportDependency(param.string, expr.range, exports);
-					dep.loc = expr.loc;
+					const dep = new ImportDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports,
+						attributes
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
 				return true;
-			} else {
-				if (
-					mode !== "lazy" &&
-					mode !== "lazy-once" &&
-					mode !== "eager" &&
-					mode !== "weak"
-				) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-					mode = "lazy";
-				}
-
-				if (mode === "weak") {
-					mode = "async-weak";
-				}
-				const dep = ContextDependencyHelpers.create(
-					ImportContextDependency,
-					expr.range,
-					param,
-					expr,
-					this.options,
-					{
-						chunkName,
-						groupOptions,
-						include,
-						exclude,
-						mode,
-						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
-							? "strict"
-							: true,
-						typePrefix: "import()",
-						category: "esm",
-						referencedExports: exports
-					},
-					parser
-				);
-				if (!dep) return;
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
 			}
+			if (mode === "weak") {
+				mode = "async-weak";
+			}
+			const dep = ContextDependencyHelpers.create(
+				ImportContextDependency,
+				/** @type {Range} */ (expr.range),
+				param,
+				expr,
+				this.options,
+				{
+					chunkName,
+					groupOptions,
+					include,
+					exclude,
+					mode,
+					namespaceObject: /** @type {BuildMeta} */ (
+						parser.state.module.buildMeta
+					).strictHarmonyModule
+						? "strict"
+						: true,
+					typePrefix: "import()",
+					category: "esm",
+					referencedExports: exports,
+					attributes: getAttributes(expr)
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
 		});
 	}
 }