webpack 5.108.3 → 5.109.0

package/lib/dependencies/HtmlSourceDependency.js

@@ -39,6 +39,18 @@ class HtmlSourceDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
 		this.range = range;
+		/** @type {true | undefined} */
+		this.prefetch = undefined;
+		/** @type {true | undefined} */
+		this.preload = undefined;
+		/** @type {"low" | "high" | "auto" | undefined} */
+		this.fetchPriority = undefined;
+		/** @type {string | undefined} */
+		this.asAttribute = undefined;
+		/** @type {string | undefined} */
+		this.typeAttribute = undefined;
+		/** @type {string | undefined} */
+		this.mediaAttribute = undefined;
 	}
 
 	get type() {
@@ -78,6 +90,13 @@ class HtmlSourceDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
+		const { write } = context;
+		write(this.prefetch);
+		write(this.preload);
+		write(this.fetchPriority);
+		write(this.asAttribute);
+		write(this.typeAttribute);
+		write(this.mediaAttribute);
 		super.serialize(context);
 	}
 
@@ -86,6 +105,13 @@ class HtmlSourceDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
+		const { read } = context;
+		this.prefetch = read();
+		this.preload = read();
+		this.fetchPriority = read();
+		this.asAttribute = read();
+		this.typeAttribute = read();
+		this.mediaAttribute = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/ImportDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 const { ImportPhaseUtils } = require("./ImportPhase");
@@ -50,6 +51,11 @@ class ImportDependency extends ModuleDependency {
 		this.attributes = attributes;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		// Range of the `import(specifier, options)` second argument, set only when
+		// it is not a statically extractable attributes object and must therefore
+		// be evaluated and validated at runtime.
+		/** @type {Range | undefined} */
+		this.optionsRange = undefined;
 	}
 
 	get type() {
@@ -137,6 +143,7 @@ class ImportDependency extends ModuleDependency {
 		context.write(this.phase);
 		context.write(this.attributes);
 		context.write(this.branchGuards);
+		context.write(this.optionsRange);
 		super.serialize(context);
 	}
 
@@ -150,6 +157,7 @@ class ImportDependency extends ModuleDependency {
 		this.phase = context.read();
 		this.attributes = context.read();
 		this.branchGuards = context.read();
+		this.optionsRange = context.read();
 		super.deserialize(context);
 	}
 }
@@ -200,7 +208,8 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			dependency: dep,
 			message: "import()",
-			runtimeRequirements
+			runtimeRequirements,
+			originModule: module
 		});
 
 		// For source phase imports, unwrap the default export
@@ -212,6 +221,39 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			)})`;
 		}
 
+		// A non-static second argument must still be evaluated (for its side
+		// effects and evaluation order) and validated per spec. Keep it in place
+		// and wrap it in an inline validator that mirrors the runtime checks of
+		// the spec's `import(specifier, options)` evaluation.
+		if (dep.optionsRange) {
+			const validator = runtimeTemplate.basicFunction("o", [
+				"try {",
+				Template.indent([
+					"if (o !== undefined) {",
+					Template.indent([
+						'if ((typeof o !== "object" && typeof o !== "function") || o === null) throw new TypeError("The second argument to import() must be an object");',
+						'var a = o["with"];',
+						"if (a !== undefined) {",
+						Template.indent([
+							'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+							"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+							Template.indent([
+								'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+							]),
+							"}"
+						]),
+						"}"
+					]),
+					"}"
+				]),
+				"} catch (e) { return Promise.reject(e); }",
+				`return ${content};`
+			]);
+			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${validator})(`);
+			source.replace(dep.optionsRange[1], dep.range[1] - 1, ")");
+			return;
+		}
+
 		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 };

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -29,18 +29,18 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 
 /**
  * Creates a property parse error.
+ * @param {JavascriptParser} parser the parser
  * @param {Property} prop property
  * @param {string} expect except message
  * @returns {WebpackError} error
  */
-function createPropertyParseError(prop, expect) {
+function createPropertyParseError(parser, prop, expect) {
 	return createError(
 		`Parsing import.meta.webpackContext options failed. Unknown value for property ${JSON.stringify(
 			/** @type {Identifier} */
 			(prop.key).name
 		)}, expected type ${expect}.`,
-		/** @type {DependencyLocation} */
-		(prop.value.loc)
+		parser.getLocation(prop.value)
 	);
 }
 
@@ -110,8 +110,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 							errors.push(
 								createError(
 									"Parsing import.meta.webpackContext options failed.",
-									/** @type {DependencyLocation} */
-									(optionsNode.loc)
+									parser.getLocation(optionsNode)
 								)
 							);
 							break;
@@ -122,7 +121,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									regExp = /** @type {RegExp} */ (regExpExpr.regExp);
 								}
@@ -133,7 +132,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									include = regExpExpr.regExp;
 								}
@@ -144,7 +143,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									exclude = regExpExpr.regExp;
 								}
@@ -155,7 +154,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!modeExpr.isString()) {
-									errors.push(createPropertyParseError(prop, "string"));
+									errors.push(createPropertyParseError(parser, prop, "string"));
 								} else {
 									mode = /** @type {ContextModuleOptions["mode"]} */ (
 										modeExpr.string
@@ -168,7 +167,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!expr.isString()) {
-									errors.push(createPropertyParseError(prop, "string"));
+									errors.push(createPropertyParseError(parser, prop, "string"));
 								} else {
 									chunkName = expr.string;
 								}
@@ -206,12 +205,16 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										}
 									} else {
 										errors.push(
-											createPropertyParseError(prop, "string|string[][]")
+											createPropertyParseError(
+												parser,
+												prop,
+												"string|string[][]"
+											)
 										);
 									}
 								} else {
 									errors.push(
-										createPropertyParseError(prop, "string|string[][]")
+										createPropertyParseError(parser, prop, "string|string[][]")
 									);
 								}
 								break;
@@ -225,7 +228,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 								} else if (expr.isNumber()) {
 									groupOptions.prefetchOrder = expr.number;
 								} else {
-									errors.push(createPropertyParseError(prop, "boolean|number"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean|number")
+									);
 								}
 								break;
 							}
@@ -238,7 +243,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 								} else if (expr.isNumber()) {
 									groupOptions.preloadOrder = expr.number;
 								} else {
-									errors.push(createPropertyParseError(prop, "boolean|number"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean|number")
+									);
 								}
 								break;
 							}
@@ -258,7 +265,11 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										);
 								} else {
 									errors.push(
-										createPropertyParseError(prop, '"high"|"low"|"auto"')
+										createPropertyParseError(
+											parser,
+											prop,
+											'"high"|"low"|"auto"'
+										)
 									);
 								}
 								break;
@@ -268,7 +279,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!recursiveExpr.isBoolean()) {
-									errors.push(createPropertyParseError(prop, "boolean"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean")
+									);
 								} else {
 									recursive = /** @type {boolean} */ (recursiveExpr.bool);
 								}
@@ -280,7 +293,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										`Parsing import.meta.webpackContext options failed. Unknown property ${JSON.stringify(
 											prop.key.name
 										)}.`,
-										/** @type {DependencyLocation} */ (optionsNode.loc)
+										parser.getLocation(optionsNode)
 									)
 								);
 						}
@@ -306,7 +319,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 					},
 					/** @type {Range} */ (expr.range)
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 				return true;

package/lib/dependencies/ImportMetaContextPlugin.js

@@ -12,6 +12,9 @@ const {
 const ContextElementDependency = require("./ContextElementDependency");
 const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDependencyParserPlugin");
+const ImportMetaGlobDependency = require("./ImportMetaGlobDependency");
+const ImportMetaGlobDependencyParserPlugin = require("./ImportMetaGlobDependencyParserPlugin");
+const { isImportMetaFieldEnabled } = require("./ImportMetaPlugin");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -19,6 +22,28 @@ const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDepe
 
 const PLUGIN_NAME = "ImportMetaContextPlugin";
 
+/** @type {(parserOptions: JavascriptParserOptions) => boolean} */
+const isImportMetaContextEnabled = (parserOptions) => {
+	const importMeta = parserOptions.importMeta;
+	if (
+		Boolean(importMeta) &&
+		typeof importMeta === "object" &&
+		Object.prototype.hasOwnProperty.call(importMeta, "webpackContext")
+	) {
+		return isImportMetaFieldEnabled(importMeta, "webpackContext");
+	}
+	if (parserOptions.importMetaContext === false) {
+		return false;
+	}
+	return isImportMetaFieldEnabled(importMeta, "webpackContext");
+};
+
+// Gated only by the `importMeta.glob` field — independent of the legacy
+// `importMetaContext` toggle, which controls `import.meta.webpackContext`.
+/** @type {(parserOptions: JavascriptParserOptions) => boolean} */
+const isImportMetaGlobEnabled = (parserOptions) =>
+	isImportMetaFieldEnabled(parserOptions.importMeta, "glob");
+
 class ImportMetaContextPlugin {
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -37,6 +62,14 @@ class ImportMetaContextPlugin {
 					ImportMetaContextDependency,
 					new ImportMetaContextDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					ImportMetaGlobDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaGlobDependency,
+					new ImportMetaGlobDependency.Template()
+				);
 				compilation.dependencyFactories.set(
 					ContextElementDependency,
 					normalModuleFactory
@@ -49,14 +82,12 @@ class ImportMetaContextPlugin {
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.importMetaContext !== undefined &&
-						!parserOptions.importMetaContext
-					) {
-						return;
+					if (isImportMetaContextEnabled(parserOptions)) {
+						new ImportMetaContextDependencyParserPlugin().apply(parser);
+					}
+					if (isImportMetaGlobEnabled(parserOptions)) {
+						new ImportMetaGlobDependencyParserPlugin().apply(parser);
 					}
-
-					new ImportMetaContextDependencyParserPlugin().apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser

package/lib/dependencies/ImportMetaGlobDependency.js

@@ -0,0 +1,81 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+/**
+ * @typedef {ContextDependencyOptions & {
+ * patterns: string[],
+ * requestContext: string,
+ * importName?: string,
+ * exhaustive?: boolean,
+ * caseSensitive?: boolean,
+ * }} ImportMetaGlobDependencyOptions
+ */
+
+class ImportMetaGlobDependency extends ContextDependency {
+	/**
+	 * @param {ImportMetaGlobDependencyOptions} options options
+	 * @param {Range} range range
+	 */
+	constructor(options, range) {
+		super(options, options ? options.requestContext : undefined);
+
+		this.range = range;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return `import.meta.glob ${this.options.mode}`;
+	}
+
+	/**
+	 * Returns an identifier to merge equal requests.
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		const {
+			patterns,
+			request,
+			recursive,
+			mode,
+			exhaustive,
+			caseSensitive,
+			importName,
+			referencedExports
+		} = /** @type {ImportMetaGlobDependencyOptions} */ (this.options);
+		return (
+			`context${this.getContext() || ""}|glob request${request} ` +
+			`${recursive} ${patterns.join(",")} ` +
+			`${mode}${exhaustive ? " exhaustive" : ""}` +
+			`${caseSensitive === false ? " case-insensitive" : ""}` +
+			`${importName ? ` import:${importName}` : ""}` +
+			`${
+				referencedExports
+					? ` referencedExports:${JSON.stringify(referencedExports)}`
+					: ""
+			}`
+		);
+	}
+}
+
+makeSerializable(
+	ImportMetaGlobDependency,
+	"webpack/lib/dependencies/ImportMetaGlobDependency"
+);
+
+ImportMetaGlobDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = ImportMetaGlobDependency;

package/lib/dependencies/ImportMetaGlobDependencyParserPlugin.js

@@ -0,0 +1,78 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const {
+	evaluateToIdentifier
+} = require("../javascript/JavascriptParserHelpers");
+const ImportMetaGlobDependency = require("./ImportMetaGlobDependency");
+const { parseImportMetaGlobCall } = require("./ImportMetaGlobHelpers");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+
+const PLUGIN_NAME = "ImportMetaGlobDependencyParserPlugin";
+
+module.exports = class ImportMetaGlobDependencyParserPlugin {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.evaluateIdentifier
+			.for("import.meta.glob")
+			.tap(PLUGIN_NAME, (expr) =>
+				evaluateToIdentifier(
+					"import.meta.glob",
+					"import.meta",
+					() => ["glob"],
+					true
+				)(expr)
+			);
+		parser.hooks.call.for("import.meta.glob").tap(PLUGIN_NAME, (expr) => {
+			const {
+				options: globOptions,
+				errors,
+				warnings
+			} = parseImportMetaGlobCall(/** @type {CallExpression} */ (expr), parser);
+			for (const warning of warnings) {
+				parser.state.module.addWarning(warning);
+			}
+			if (errors.length) {
+				for (const error of errors) parser.state.current.addError(error);
+				return;
+			}
+			if (!globOptions) return;
+			const dep = new ImportMetaGlobDependency(
+				{
+					request: `${globOptions.baseDir}${globOptions.query}`,
+					recursive: globOptions.recursive,
+					regExp: false,
+					patterns: globOptions.patterns,
+					requestContext: globOptions.requestContext,
+					importName: globOptions.importName,
+					exhaustive: globOptions.exhaustive,
+					caseSensitive: globOptions.caseSensitive,
+					referencedExports: globOptions.referencedExports,
+					namespaceObject:
+						/** @type {import("../Module").BuildMeta} */
+						(parser.state.module.buildMeta).strictHarmonyModule
+							? "strict"
+							: true,
+					mode: globOptions.mode,
+					category: "esm"
+				},
+				globOptions.range
+			);
+			dep.loc = parser.getLocation(expr);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+	}
+};