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

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 */
@@ -26,6 +34,7 @@ const { join } = require("./util/fs");
 /** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
@@ -34,6 +43,7 @@ const { join } = require("./util/fs");
 /** @typedef {{ context: string, request: string }} ContextAlternativeRequest */
 
 /**
+ * Defines the context resolve data type used by this module.
  * @typedef {object} ContextResolveData
  * @property {string} context
  * @property {string} request
@@ -51,6 +61,7 @@ const EMPTY_RESOLVE_OPTIONS = {};
 
 class ContextModuleFactory extends ModuleFactory {
 	/**
+	 * Creates an instance of ContextModuleFactory.
 	 * @param {ResolverFactory} resolverFactory resolverFactory
 	 */
 	constructor(resolverFactory) {
@@ -102,6 +113,7 @@ class ContextModuleFactory extends ModuleFactory {
 	}
 
 	/**
+	 * Processes the provided data.
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
@@ -195,6 +207,7 @@ class ContextModuleFactory extends ModuleFactory {
 						(callback) => {
 							const results = /** @type {ResolveRequest[]} */ ([]);
 							/**
+							 * Processes the provided obj.
 							 * @param {ResolveRequest} obj obj
 							 * @returns {void}
 							 */
@@ -304,6 +317,7 @@ class ContextModuleFactory extends ModuleFactory {
 	}
 
 	/**
+	 * Resolves dependencies.
 	 * @param {InputFileSystem} fs file system
 	 * @param {ContextModuleOptions} options options
 	 * @param {ResolveDependenciesCallback} callback callback function
@@ -317,6 +331,10 @@ class ContextModuleFactory extends ModuleFactory {
 			resourceFragment,
 			recursive,
 			regExp,
+			patterns,
+			requestContext,
+			exhaustive,
+			caseSensitive,
 			include,
 			exclude,
 			referencedExports,
@@ -324,15 +342,24 @@ 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.
 		 * @param {string} ctx context
 		 * @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);
@@ -348,21 +375,36 @@ 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
 				);
 			});
 		};
 
 		/**
+		 * 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(
@@ -371,8 +413,16 @@ class ContextModuleFactory extends ModuleFactory {
 				if (!processedFiles || processedFiles.length === 0) {
 					return callback(null, []);
 				}
+				/** @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);
 
@@ -391,46 +441,75 @@ 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))
 								) {
-									/** @type {{ context: string, request: string }} */
-									const obj = {
-										context: ctx,
-										request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}`
-									};
-
-									this.hooks.alternativeRequests.callAsync(
-										[obj],
-										options,
-										(err, alternatives) => {
-											if (err) return callback(err);
-											callback(
-												null,
-												/** @type {ContextAlternativeRequest[]} */
-												(alternatives)
-													.filter((obj) =>
-														regExp.test(/** @type {string} */ (obj.request))
-													)
-													.map((obj) => {
-														const dep = new ContextElementDependency(
-															`${obj.request}${resourceQuery}${resourceFragment}`,
-															obj.request,
-															typePrefix,
-															/** @type {string} */
-															(category),
-															referencedExports,
-															obj.context,
-															attributes
-														);
-														dep.optional = true;
-														return dep;
-													})
+									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
+									// lookup, array allocations) for every file in the
+									// context — which is the bulk of work on rebuilds.
+									fileObjs.push({
+										context: ctx,
+										request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}`
+									});
+									callback();
 								} else {
 									callback();
 								}
@@ -442,45 +521,108 @@ class ContextModuleFactory extends ModuleFactory {
 					(err, result) => {
 						if (err) return callback(err);
 
-						if (!result) return callback(null, []);
-
 						/** @type {ContextElementDependency[]} */
 						const flattenedResult = [];
 
-						for (const item of result) {
-							if (item) flattenedResult.push(...item);
+						if (result) {
+							for (const item of result) {
+								if (item) flattenedResult.push(...item);
+							}
 						}
 
-						callback(null, flattenedResult);
+						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);
+						}
+
+						this.hooks.alternativeRequests.callAsync(
+							fileObjs,
+							options,
+							(err, alternatives) => {
+								if (err) return callback(err);
+								for (const alt of /** @type {ContextAlternativeRequest[]} */ (
+									alternatives
+								)) {
+									if (
+										!(regExp instanceof RegExp) ||
+										!regExp.test(/** @type {string} */ (alt.request))
+									) {
+										continue;
+									}
+									const dep = new ContextElementDependency(
+										`${alt.request}${resourceQuery}${resourceFragment}`,
+										alt.request,
+										typePrefix,
+										/** @type {string} */
+										(category),
+										referencedExports,
+										alt.context,
+										attributes
+									);
+									dep.optional = true;
+									flattenedResult.push(dep);
+								}
+								callback(null, flattenedResult);
+							}
+						);
 					}
 				);
 			});
 		};
 
 		/**
+		 * Adds sub directory.
 		 * @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.
 		 * @param {string} resource resource
 		 * @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
+				);
 			}
 		};
 

package/lib/ContextReplacementPlugin.js

@@ -20,6 +20,7 @@ const PLUGIN_NAME = "ContextReplacementPlugin";
 
 class ContextReplacementPlugin {
 	/**
+	 * Creates an instance of ContextReplacementPlugin.
 	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
 	 * @param {(string | ((context: BeforeContextResolveData | AfterContextResolveData) => void) | RegExp | boolean)=} newContentResource A new resource to replace the match
 	 * @param {(boolean | NewContentCreateContextMap | RegExp)=} newContentRecursive If true, all subdirectories are searched for matches
@@ -31,6 +32,7 @@ class ContextReplacementPlugin {
 		newContentRecursive,
 		newContentRegExp
 	) {
+		/** @type {RegExp} */
 		this.resourceRegExp = resourceRegExp;
 
 		// new webpack.ContextReplacementPlugin(/selector/, (context) => { /* Logic */ });
@@ -42,8 +44,10 @@ class ContextReplacementPlugin {
 			typeof newContentResource === "string" &&
 			typeof newContentRecursive === "object"
 		) {
+			/** @type {string | undefined} */
 			this.newContentResource = newContentResource;
 			/**
+			 * Stores new content create context map.
 			 * @param {InputFileSystem} fs input file system
 			 * @param {(err: null | Error, newContentRecursive: NewContentCreateContextMap) => void} callback callback
 			 */
@@ -77,9 +81,11 @@ class ContextReplacementPlugin {
 			this.newContentResource =
 				/** @type {string | undefined} */
 				(newContentResource);
+			/** @type {boolean | undefined} */
 			this.newContentRecursive =
 				/** @type {boolean | undefined} */
 				(newContentRecursive);
+			/** @type {RegExp | undefined} */
 			this.newContentRegExp =
 				/** @type {RegExp | undefined} */
 				(newContentRegExp);
@@ -87,7 +93,7 @@ class ContextReplacementPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -202,6 +208,7 @@ class ContextReplacementPlugin {
 }
 
 /**
+ * Creates a resolve dependencies from context map.
  * @param {(fs: InputFileSystem, callback: (err: null | Error, map: NewContentCreateContextMap) => void) => void} createContextMap create context map function
  * @returns {(fs: InputFileSystem, options: ContextModuleOptions, callback: (err: null | Error, dependencies?: ContextElementDependency[]) => void) => void} resolve resolve dependencies from context map function
  */