webpack 5.97.1 → 5.104.1

package/lib/ContextReplacementPlugin.js

@@ -9,13 +9,20 @@ const ContextElementDependency = require("./dependencies/ContextElementDependenc
 const { join } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
+/** @typedef {import("./ContextModuleFactory").AfterContextResolveData} AfterContextResolveData */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {Record<string, string>} NewContentCreateContextMap */
+
+const PLUGIN_NAME = "ContextReplacementPlugin";
+
 class ContextReplacementPlugin {
 	/**
 	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
-	 * @param {TODO=} newContentResource A new resource to replace the match
-	 * @param {TODO=} newContentRecursive If true, all subdirectories are searched for matches
+	 * @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
 	 * @param {RegExp=} newContentRegExp A regular expression that determines which files will be selected
 	 */
 	constructor(
@@ -26,35 +33,56 @@ class ContextReplacementPlugin {
 	) {
 		this.resourceRegExp = resourceRegExp;
 
+		// new webpack.ContextReplacementPlugin(/selector/, (context) => { /* Logic */ });
 		if (typeof newContentResource === "function") {
 			this.newContentCallback = newContentResource;
-		} else if (
+		}
+		// new ContextReplacementPlugin(/selector/, './folder', { './request': './request' });
+		else if (
 			typeof newContentResource === "string" &&
 			typeof newContentRecursive === "object"
 		) {
 			this.newContentResource = newContentResource;
+			/**
+			 * @param {InputFileSystem} fs input file system
+			 * @param {(err: null | Error, newContentRecursive: NewContentCreateContextMap) => void} callback callback
+			 */
 			this.newContentCreateContextMap = (fs, callback) => {
-				callback(null, newContentRecursive);
+				callback(
+					null,
+					/** @type {NewContentCreateContextMap} */ (newContentRecursive)
+				);
 			};
-		} else if (
+		}
+		// new ContextReplacementPlugin(/selector/, './folder', (context) => { /* Logic */ });
+		else if (
 			typeof newContentResource === "string" &&
 			typeof newContentRecursive === "function"
 		) {
 			this.newContentResource = newContentResource;
 			this.newContentCreateContextMap = newContentRecursive;
 		} else {
+			// new webpack.ContextReplacementPlugin(/selector/, false, /reg-exp/);
 			if (typeof newContentResource !== "string") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = newContentResource;
+				newContentRegExp = /** @type {RegExp} */ (newContentRecursive);
+				newContentRecursive = /** @type {boolean} */ (newContentResource);
 				newContentResource = undefined;
 			}
+			// new webpack.ContextReplacementPlugin(/selector/, /de|fr|hu/);
 			if (typeof newContentRecursive !== "boolean") {
-				newContentRegExp = newContentRecursive;
+				newContentRegExp = /** @type {RegExp} */ (newContentRecursive);
 				newContentRecursive = undefined;
 			}
-			this.newContentResource = newContentResource;
-			this.newContentRecursive = newContentRecursive;
-			this.newContentRegExp = newContentRegExp;
+			// new webpack.ContextReplacementPlugin(/selector/, './folder', false, /selector/);
+			this.newContentResource =
+				/** @type {string | undefined} */
+				(newContentResource);
+			this.newContentRecursive =
+				/** @type {boolean | undefined} */
+				(newContentRecursive);
+			this.newContentRegExp =
+				/** @type {RegExp | undefined} */
+				(newContentRegExp);
 		}
 	}
 
@@ -71,8 +99,8 @@ class ContextReplacementPlugin {
 		const newContentRegExp = this.newContentRegExp;
 		const newContentCreateContextMap = this.newContentCreateContextMap;
 
-		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
+			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, (result) => {
 				if (!result) return;
 				if (resourceRegExp.test(result.request)) {
 					if (newContentResource !== undefined) {
@@ -94,9 +122,16 @@ class ContextReplacementPlugin {
 				}
 				return result;
 			});
-			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
+			cmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => {
 				if (!result) return;
-				if (resourceRegExp.test(result.resource)) {
+				const isMatchResourceRegExp = () => {
+					if (Array.isArray(result.resource)) {
+						return result.resource.some((item) => resourceRegExp.test(item));
+					}
+
+					return resourceRegExp.test(result.resource);
+				};
+				if (isMatchResourceRegExp()) {
 					if (newContentResource !== undefined) {
 						if (
 							newContentResource.startsWith("/") ||
@@ -104,9 +139,15 @@ class ContextReplacementPlugin {
 						) {
 							result.resource = newContentResource;
 						} else {
+							const rootPath =
+								typeof result.resource === "string"
+									? result.resource
+									: /** @type {string} */
+										(result.resource.find((item) => resourceRegExp.test(item)));
 							result.resource = join(
-								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
-								result.resource,
+								/** @type {InputFileSystem} */
+								(compiler.inputFileSystem),
+								rootPath,
 								newContentResource
 							);
 						}
@@ -126,17 +167,27 @@ class ContextReplacementPlugin {
 					if (typeof newContentCallback === "function") {
 						const origResource = result.resource;
 						newContentCallback(result);
-						if (
-							result.resource !== origResource &&
-							!result.resource.startsWith("/") &&
-							(result.resource.length <= 1 || result.resource[1] !== ":")
-						) {
-							// When the function changed it to an relative path
-							result.resource = join(
-								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
-								origResource,
-								result.resource
-							);
+						if (result.resource !== origResource) {
+							const newResource = Array.isArray(result.resource)
+								? result.resource
+								: [result.resource];
+
+							for (let i = 0; i < newResource.length; i++) {
+								if (
+									!newResource[i].startsWith("/") &&
+									(newResource[i].length <= 1 || newResource[i][1] !== ":")
+								) {
+									// When the function changed it to an relative path
+									newResource[i] = join(
+										/** @type {InputFileSystem} */
+										(compiler.inputFileSystem),
+										origResource[i],
+										newResource[i]
+									);
+								}
+							}
+
+							result.resource = newResource;
 						}
 					} else {
 						for (const d of result.dependencies) {
@@ -150,23 +201,27 @@ class ContextReplacementPlugin {
 	}
 }
 
-const createResolveDependenciesFromContextMap = createContextMap => {
-	const resolveDependenciesFromContextMap = (fs, options, callback) => {
+/**
+ * @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
+ */
+const createResolveDependenciesFromContextMap =
+	(createContextMap) => (fs, options, callback) => {
 		createContextMap(fs, (err, map) => {
 			if (err) return callback(err);
 			const dependencies = Object.keys(map).map(
-				key =>
+				(key) =>
 					new ContextElementDependency(
 						map[key] + options.resourceQuery + options.resourceFragment,
 						key,
-						options.category,
+						options.typePrefix,
+						/** @type {string} */
+						(options.category),
 						options.referencedExports
 					)
 			);
 			callback(null, dependencies);
 		});
 	};
-	return resolveDependenciesFromContextMap;
-};
 
 module.exports = ContextReplacementPlugin;

package/lib/CssModule.js

@@ -18,9 +18,9 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {string | undefined} Supports */
 /** @typedef {string | undefined} Media */
 /** @typedef {[CssLayer, Supports, Media]} InheritanceItem */
-/** @typedef {Array<InheritanceItem>} Inheritance */
+/** @typedef {InheritanceItem[]} Inheritance */
 
-/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer, supports: Supports, media: Media, inheritance: Inheritance }} CSSModuleCreateData */
+/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer, supports: Supports, media: Media, inheritance?: Inheritance }} CSSModuleCreateData */
 
 class CssModule extends NormalModule {
 	/**
@@ -30,9 +30,13 @@ class CssModule extends NormalModule {
 		super(options);
 
 		// Avoid override `layer` for `Module` class, because it is a feature to run module in specific layer
+		/** @type {CSSModuleCreateData['cssLayer']} */
 		this.cssLayer = options.cssLayer;
+		/** @type {CSSModuleCreateData['supports']} */
 		this.supports = options.supports;
+		/** @type {CSSModuleCreateData['media']} */
 		this.media = options.media;
+		/** @type {CSSModuleCreateData['inheritance']} */
 		this.inheritance = options.inheritance;
 	}
 
@@ -150,7 +154,8 @@ class CssModule extends NormalModule {
 			cssLayer: /** @type {EXPECTED_ANY} */ (null),
 			supports: /** @type {EXPECTED_ANY} */ (null),
 			media: /** @type {EXPECTED_ANY} */ (null),
-			inheritance: /** @type {EXPECTED_ANY} */ (null)
+			inheritance: /** @type {EXPECTED_ANY} */ (null),
+			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;
@@ -158,7 +163,6 @@ class CssModule extends NormalModule {
 
 	/**
 	 * @param {ObjectDeserializerContext} context context
-	 * @returns {TODO} Module
 	 */
 	deserialize(context) {
 		const { read } = context;