webpack 5.108.4 → 5.109.1

package/lib/ContextModule.js

@@ -34,6 +34,7 @@ const {
 	parseResource
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
+const { propertyAccess } = require("./util/property");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
@@ -90,6 +91,11 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {string | null=} layer
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType=} phase
+ * @property {string[]=} patterns glob patterns for import.meta.glob
+ * @property {string=} requestContext importer context for import.meta.glob
+ * @property {string=} importName import selection for import.meta.glob
+ * @property {boolean=} exhaustive exhaustive mode for import.meta.glob
+ * @property {boolean=} caseSensitive case-sensitive matching for import.meta.glob
  */
 
 /**
@@ -226,7 +232,14 @@ class ContextModule extends Module {
 		const str = stripSlash
 			? regexString.source + regexString.flags
 			: `${regexString}`;
-		return str.replace(/!/g, "%21").replace(/\|/g, "%7C");
+		// Escape chars that are structural in the identifier/source-name URL
+		// (`!`/`|` separators, `?` query, `#` fragment) so a regex like
+		// `(?:a|b)` isn't misread and truncated when it becomes a source name.
+		return str
+			.replace(/!/g, "%21")
+			.replace(/\|/g, "%7C")
+			.replace(/\?/g, "%3F")
+			.replace(/#/g, "%23");
 	}
 
 	_createIdentifier() {
@@ -253,6 +266,11 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
+		} else if (this.options.patterns) {
+			identifier += `|patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += `|requestContext: ${this.options.requestContext}`;
 		}
 		if (this.options.include) {
 			identifier += `|include: ${this._prettyRegExp(
@@ -271,6 +289,15 @@ class ContextModule extends Module {
 				this.options.referencedExports
 			)}`;
 		}
+		if (this.options.importName) {
+			identifier += `|import: ${this.options.importName}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += "|exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += "|case-insensitive";
+		}
 		if (this.options.chunkName) {
 			identifier += `|chunkName: ${this.options.chunkName}`;
 		}
@@ -339,6 +366,17 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		} else if (this.options.patterns) {
+			identifier += ` patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += ` requestContext: ${this.options.requestContext}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += " exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += " case-insensitive";
 		}
 		if (this.options.include) {
 			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
@@ -418,6 +456,17 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		} else if (this.options.patterns) {
+			identifier += ` patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += ` requestContext: ${this.options.requestContext}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += " exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += " case-insensitive";
 		}
 		if (this.options.include) {
 			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
@@ -1184,7 +1233,8 @@ module.exports = webpackAsyncContext;`;
 		}
 
 		const chunksPosition = hasFakeMap ? 2 : 1;
-		const asyncDepsPosition = chunksPosition + 1;
+		// No chunks slot is pushed when `hasNoChunk`, so `asyncDeps` sits at `chunksPosition`.
+		const asyncDepsPosition = hasNoChunk ? chunksPosition : chunksPosition + 1;
 		const requestPrefix = hasNoChunk
 			? "Promise.resolve()"
 			: hasMultipleOrNoChunks
@@ -1278,13 +1328,196 @@ webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
 module.exports = webpackEmptyAsyncContext;`;
 	}
 
+	/**
+	 * @returns {string | undefined} import property access
+	 */
+	getImportPropertyAccess() {
+		const importName = this.options.importName;
+		if (!importName || importName === "*") return;
+		return propertyAccess([importName]);
+	}
+
+	/**
+	 * @param {number} index index
+	 * @param {string} userRequest user request
+	 * @param {string} value value expression
+	 * @param {string[]} entries entries
+	 * @returns {void}
+	 */
+	appendGlobMapEntry(index, userRequest, value, entries) {
+		entries.push(`\n  ${JSON.stringify(userRequest)}: ${value}`);
+	}
+
+	/**
+	 * @param {string} entries entries
+	 * @returns {string} object export source
+	 */
+	getGlobObjectExportSource(entries) {
+		return `\nmodule.exports = {${entries}\n};\n`;
+	}
+
+	/**
+	 * @returns {string} empty object export source
+	 */
+	getEmptyObjectExportSource() {
+		return "\nmodule.exports = {};\n";
+	}
+
+	/**
+	 * @param {AsyncDependenciesBlock[]} blocks blocks
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {object} context context
+	 * @param {RuntimeTemplate} context.runtimeTemplate runtime template
+	 * @param {ChunkGraph} context.chunkGraph chunk graph
+	 * @param {RuntimeRequirements=} context.runtimeRequirements runtime requirements
+	 * @returns {string} glob lazy source
+	 */
+	getGlobLazySource(
+		blocks,
+		phase,
+		{ runtimeTemplate, chunkGraph, runtimeRequirements }
+	) {
+		if (!blocks || blocks.length === 0) {
+			return this.getEmptyObjectExportSource();
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		const globImportAccess = this.getImportPropertyAccess();
+		/** @type {RuntimeRequirements} */
+		const localRuntimeRequirements = runtimeRequirements || new Set();
+		/** @type {{ userRequest: string, block: AsyncDependenciesBlock, dependency: ContextElementDependency }[]} */
+		const blockInfo = blocks
+			.map((block) => {
+				const dependency =
+					/** @type {ContextElementDependency} */
+					(block.dependencies[0]);
+				return {
+					userRequest: dependency.userRequest,
+					block,
+					dependency
+				};
+			})
+			.sort((a, b) =>
+				a.userRequest < b.userRequest
+					? -1
+					: a.userRequest > b.userRequest
+						? 1
+						: 0
+			);
+		/** @type {string[]} */
+		const entries = [];
+		for (let i = 0; i < blockInfo.length; i++) {
+			const info = blockInfo[i];
+			let importPromise = runtimeTemplate.moduleNamespacePromise({
+				chunkGraph,
+				block: info.block,
+				module: /** @type {Module} */ (moduleGraph.getModule(info.dependency)),
+				request: info.userRequest,
+				message: "import.meta.glob",
+				strict: this.options.namespaceObject === "strict",
+				dependency: info.dependency,
+				runtimeRequirements: localRuntimeRequirements
+			});
+			if (globImportAccess) {
+				importPromise = `${importPromise}.then(function(m) { return m${globImportAccess}; })`;
+			}
+			this.appendGlobMapEntry(
+				i,
+				info.userRequest,
+				`function() { return ${importPromise}; }`,
+				entries
+			);
+		}
+		return this.getGlobObjectExportSource(entries.join(","));
+	}
+
+	/**
+	 * @param {Dependency[]} dependencies dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} glob sync source
+	 */
+	getGlobSyncSource(dependencies, chunkGraph, runtimeTemplate) {
+		if (!dependencies || dependencies.length === 0) {
+			return this.getEmptyObjectExportSource();
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+		const globImportAccess = this.getImportPropertyAccess();
+		const sortedDependencies =
+			/** @type {import("./dependencies/ContextElementDependency")[]} */
+			(dependencies).sort((a, b) =>
+				a.userRequest < b.userRequest
+					? -1
+					: a.userRequest > b.userRequest
+						? 1
+						: 0
+			);
+		/** @type {string[]} */
+		const entries = [];
+		let index = 0;
+		for (const dep of sortedDependencies) {
+			const module = moduleGraph.getModule(dep);
+			let moduleExpr;
+			if (module) {
+				const moduleId = chunkGraph.getModuleId(module);
+				moduleExpr = `(function() { var id = ${JSON.stringify(moduleId)}; return ${returnModuleObject}; })()`;
+				if (globImportAccess) {
+					moduleExpr += globImportAccess;
+				}
+			} else {
+				moduleExpr = `undefined /* ${JSON.stringify(dep.userRequest)} */`;
+			}
+			this.appendGlobMapEntry(index++, dep.userRequest, moduleExpr, entries);
+		}
+		const fakeMapInit = this.getFakeMapInitStatement(fakeMap, runtimeTemplate);
+		return `${fakeMapInit}\n${this.getGlobObjectExportSource(entries.join(","))}`;
+	}
+
 	/**
 	 * @param {string} asyncMode module mode
 	 * @param {ImportPhaseType} phase import phase
 	 * @param {CodeGenerationContext} context context info
 	 * @returns {string} the source code
 	 */
-	getSourceString(asyncMode, phase, { runtimeTemplate, chunkGraph }) {
+	getGlobSourceString(asyncMode, phase, context) {
+		if (asyncMode === "lazy") {
+			if (this.blocks && this.blocks.length > 0) {
+				return this.getGlobLazySource(this.blocks, phase, context);
+			}
+			return this.getEmptyObjectExportSource();
+		}
+		if (this.dependencies && this.dependencies.length > 0) {
+			return this.getGlobSyncSource(
+				this.dependencies,
+				context.chunkGraph,
+				context.runtimeTemplate
+			);
+		}
+		return this.getEmptyObjectExportSource();
+	}
+
+	/**
+	 * @param {string} asyncMode module mode
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @returns {string} the source code
+	 */
+	getSourceString(asyncMode, phase, context) {
+		if (this.options.patterns) {
+			return this.getGlobSourceString(asyncMode, phase, context);
+		}
+		return this.getContextSourceString(asyncMode, phase, context);
+	}
+
+	/**
+	 * @param {string} asyncMode module mode
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @returns {string} the source code
+	 */
+	getContextSourceString(asyncMode, phase, context) {
+		const { runtimeTemplate, chunkGraph } = context;
 		const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(this));
 		if (asyncMode === "lazy") {
 			if (this.blocks && this.blocks.length > 0) {
@@ -1373,6 +1606,8 @@ module.exports = webpackEmptyAsyncContext;`;
 	codeGeneration(context) {
 		const { chunkGraph, compilation } = context;
 
+		/** @type {RuntimeRequirements} */
+		const set = new Set();
 		/** @type {Sources} */
 		const sources = new Map();
 		sources.set(
@@ -1381,13 +1616,11 @@ module.exports = webpackEmptyAsyncContext;`;
 				this.getSourceString(
 					this.options.mode,
 					this.options.phase || ImportPhase.Evaluation,
-					context
+					{ ...context, runtimeRequirements: set }
 				),
 				compilation
 			)
 		);
-		/** @type {RuntimeRequirements} */
-		const set = new Set();
 		const allDeps =
 			this.dependencies.length > 0
 				? /** @type {ContextElementDependency[]} */ [...this.dependencies]

package/lib/ContextModuleFactory.js

@@ -14,7 +14,15 @@ const LazySet = require("./util/LazySet");
 const { cachedSetProperty } = require("./util/cleverMerge");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
-
+const {
+	globPatternBaseReachesDir,
+	globUserRequest,
+	isNonExhaustiveImportMetaGlobSkippedDir,
+	resolveContextModuleGlobPattern
+} = require("./util/globUtils");
+
+/** @typedef {import("./util/globUtils").ResolvedContextModuleGlobPattern} ResolvedContextModuleGlobPattern */
+/** @typedef {(context: string, subResource: string, callback: () => void, resolvedGlobPatterns?: ResolvedContextModuleGlobPattern[]) => void} AddSubDirectoryFn */
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
@@ -323,6 +331,10 @@ class ContextModuleFactory extends ModuleFactory {
 			resourceFragment,
 			recursive,
 			regExp,
+			patterns,
+			requestContext,
+			exhaustive,
+			caseSensitive,
 			include,
 			exclude,
 			referencedExports,
@@ -330,7 +342,8 @@ class ContextModuleFactory extends ModuleFactory {
 			typePrefix,
 			attributes
 		} = options;
-		if (!regExp || !resource) return callback(null, []);
+		const isImportMetaGlob = Boolean(patterns && requestContext);
+		if ((!regExp && !isImportMetaGlob) || !resource) return callback(null, []);
 
 		/**
 		 * Adds directory checked.
@@ -338,8 +351,15 @@ class ContextModuleFactory extends ModuleFactory {
 		 * @param {string} directory directory
 		 * @param {Set<string>} visited visited
 		 * @param {ResolveDependenciesCallback} callback callback
+		 * @param {ResolvedContextModuleGlobPattern[] | undefined} resolvedGlobPatterns resolved glob patterns
 		 */
-		const addDirectoryChecked = (ctx, directory, visited, callback) => {
+		const addDirectoryChecked = (
+			ctx,
+			directory,
+			visited,
+			callback,
+			resolvedGlobPatterns
+		) => {
 			/** @type {NonNullable<InputFileSystem["realpath"]>} */
 			(fs.realpath)(directory, (err, _realPath) => {
 				if (err) return callback(err);
@@ -355,9 +375,16 @@ class ContextModuleFactory extends ModuleFactory {
 							recursionStack = new Set(visited);
 							recursionStack.add(realPath);
 						}
-						addDirectoryChecked(ctx, dir, recursionStack, callback);
+						addDirectoryChecked(
+							ctx,
+							dir,
+							recursionStack,
+							callback,
+							resolvedGlobPatterns
+						);
 					},
-					callback
+					callback,
+					resolvedGlobPatterns
 				);
 			});
 		};
@@ -366,11 +393,18 @@ class ContextModuleFactory extends ModuleFactory {
 		 * Adds the provided ctx to the context module factory.
 		 * @param {string} ctx context
 		 * @param {string} directory directory
-		 * @param {(context: string, subResource: string, callback: () => void) => void} addSubDirectory addSubDirectoryFn
+		 * @param {AddSubDirectoryFn} addSubDirectory addSubDirectoryFn
 		 * @param {ResolveDependenciesCallback} callback callback
+		 * @param {ResolvedContextModuleGlobPattern[] | undefined} resolvedGlobPatterns resolved glob patterns
 		 * @returns {void}
 		 */
-		const addDirectory = (ctx, directory, addSubDirectory, callback) => {
+		const addDirectory = (
+			ctx,
+			directory,
+			addSubDirectory,
+			callback,
+			resolvedGlobPatterns
+		) => {
 			fs.readdir(directory, (err, files) => {
 				if (err) return callback(err);
 				const processedFiles = cmf.hooks.contextModuleFiles.call(
@@ -381,8 +415,14 @@ class ContextModuleFactory extends ModuleFactory {
 				}
 				/** @type {ContextAlternativeRequest[]} */
 				const fileObjs = [];
+				/** @type {ContextElementDependency[]} */
+				const globDeps = [];
+				/** @type {Set<string>} */
+				const globUserRequests = new Set();
 				asyncLib.map(
-					processedFiles.filter((p) => p.indexOf(".") !== 0),
+					isImportMetaGlob
+						? processedFiles
+						: processedFiles.filter((p) => p.indexOf(".") !== 0),
 					(segment, callback) => {
 						const subResource = join(fs, directory, segment);
 
@@ -401,11 +441,65 @@ class ContextModuleFactory extends ModuleFactory {
 
 								if (stat.isDirectory()) {
 									if (!recursive) return callback();
-									addSubDirectory(ctx, subResource, callback);
+									if (
+										isImportMetaGlob &&
+										!exhaustive &&
+										isNonExhaustiveImportMetaGlobSkippedDir(segment) &&
+										!(
+											resolvedGlobPatterns &&
+											globPatternBaseReachesDir(
+												resolvedGlobPatterns,
+												subResource
+											)
+										)
+									) {
+										return callback();
+									}
+									addSubDirectory(
+										ctx,
+										subResource,
+										callback,
+										resolvedGlobPatterns
+									);
 								} else if (
 									stat.isFile() &&
 									(!include || include.test(subResource))
 								) {
+									if (
+										isImportMetaGlob &&
+										patterns &&
+										requestContext &&
+										resolvedGlobPatterns
+									) {
+										const relativePath = `.${subResource
+											.slice(ctx.length)
+											.replace(/\\/g, "/")}`;
+										const exposedUserRequest = globUserRequest(
+											resolvedGlobPatterns,
+											subResource,
+											exhaustive === true,
+											caseSensitive !== false
+										);
+										if (
+											exposedUserRequest &&
+											!globUserRequests.has(exposedUserRequest)
+										) {
+											globUserRequests.add(exposedUserRequest);
+											const dep = new ContextElementDependency(
+												`${relativePath}${resourceQuery}${resourceFragment}`,
+												exposedUserRequest,
+												typePrefix,
+												/** @type {string} */
+												(category),
+												referencedExports,
+												ctx,
+												attributes
+											);
+											dep.optional = true;
+											globDeps.push(dep);
+										}
+										return callback();
+									}
 									// Collect for a single batched alternativeRequests call
 									// per directory below. Calling the hook once per file
 									// would pay per-call overhead (closure, resolverFactory
@@ -436,6 +530,19 @@ class ContextModuleFactory extends ModuleFactory {
 							}
 						}
 
+						if (isImportMetaGlob) {
+							/** @type {Set<string>} */
+							const mergedUserRequests = new Set();
+							/** @type {ContextElementDependency[]} */
+							const merged = [];
+							for (const dep of [...flattenedResult, ...globDeps]) {
+								if (mergedUserRequests.has(dep.userRequest)) continue;
+								mergedUserRequests.add(dep.userRequest);
+								merged.push(dep);
+							}
+							return callback(null, merged);
+						}
+
 						if (fileObjs.length === 0) {
 							return callback(null, flattenedResult);
 						}
@@ -448,7 +555,10 @@ class ContextModuleFactory extends ModuleFactory {
 								for (const alt of /** @type {ContextAlternativeRequest[]} */ (
 									alternatives
 								)) {
-									if (!regExp.test(/** @type {string} */ (alt.request))) {
+									if (
+										!(regExp instanceof RegExp) ||
+										!regExp.test(/** @type {string} */ (alt.request))
+									) {
 										continue;
 									}
 									const dep = new ContextElementDependency(
@@ -477,10 +587,11 @@ class ContextModuleFactory extends ModuleFactory {
 		 * @param {string} ctx context
 		 * @param {string} dir dir
 		 * @param {ResolveDependenciesCallback} callback callback
+		 * @param {ResolvedContextModuleGlobPattern[] | undefined} resolvedGlobPatterns resolved glob patterns
 		 * @returns {void}
 		 */
-		const addSubDirectory = (ctx, dir, callback) =>
-			addDirectory(ctx, dir, addSubDirectory, callback);
+		const addSubDirectory = (ctx, dir, callback, resolvedGlobPatterns) =>
+			addDirectory(ctx, dir, addSubDirectory, callback, resolvedGlobPatterns);
 
 		/**
 		 * Processes the provided resource.
@@ -488,16 +599,30 @@ class ContextModuleFactory extends ModuleFactory {
 		 * @param {ResolveDependenciesCallback} callback callback
 		 */
 		const visitResource = (resource, callback) => {
+			/** @type {ResolvedContextModuleGlobPattern[] | undefined} */
+			const resolvedGlobPatterns =
+				isImportMetaGlob && patterns && requestContext
+					? patterns.map((pattern) =>
+							resolveContextModuleGlobPattern(pattern, requestContext, resource)
+						)
+					: undefined;
 			if (typeof fs.realpath === "function") {
 				addDirectoryChecked(
 					resource,
 					resource,
 					/** @type {Set<string>} */
 					new Set(),
-					callback
+					callback,
+					resolvedGlobPatterns
 				);
 			} else {
-				addDirectory(resource, resource, addSubDirectory, callback);
+				addDirectory(
+					resource,
+					resource,
+					addSubDirectory,
+					callback,
+					resolvedGlobPatterns
+				);
 			}
 		};