webpack 5.59.0 → 5.94.0

package/lib/ContextModuleFactory.js

@@ -22,8 +22,14 @@ const { join } = require("./util/fs");
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/**
+ * @template T
+ * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
+ */
+/** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {{ context: string, request: string }} ContextAlternativeRequest */
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
@@ -33,7 +39,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 	 */
 	constructor(resolverFactory) {
 		super();
-		/** @type {AsyncSeriesWaterfallHook<[TODO[], ContextModuleOptions]>} */
+		/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[], ContextModuleOptions]>} */
 		const alternativeRequests = new AsyncSeriesWaterfallHook([
 			"modules",
 			"options"
@@ -45,27 +51,27 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
 			/** @type {SyncWaterfallHook<[string[]]>} */
 			contextModuleFiles: new SyncWaterfallHook(["files"]),
-			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[TODO[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
 			alternatives: createFakeHook(
 				{
 					name: "alternatives",
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["intercept"]} */
+					/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["intercept"]} */
 					intercept: interceptor => {
 						throw new Error(
 							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
 						);
 					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tap"]} */
+					/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tap"]} */
 					tap: (options, fn) => {
 						alternativeRequests.tap(options, fn);
 					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapAsync"]} */
+					/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tapAsync"]} */
 					tapAsync: (options, fn) => {
 						alternativeRequests.tapAsync(options, (items, _options, callback) =>
 							fn(items, callback)
 						);
 					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapPromise"]} */
+					/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["tapPromise"]} */
 					tapPromise: (options, fn) => {
 						alternativeRequests.tapPromise(options, fn);
 					}
@@ -80,7 +86,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
@@ -93,8 +99,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 		const contextDependencies = new LazySet();
 		this.hooks.beforeResolve.callAsync(
 			{
-				context: context,
-				dependencies: dependencies,
+				context,
+				dependencies,
+				layer: data.contextInfo.issuerLayer,
 				resolveOptions,
 				fileDependencies,
 				missingDependencies,
@@ -123,12 +130,12 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				const request = beforeResolveResult.request;
 				const resolveOptions = beforeResolveResult.resolveOptions;
 
-				let loaders,
-					resource,
-					loadersPrefix = "";
+				let loaders;
+				let resource;
+				let loadersPrefix = "";
 				const idx = request.lastIndexOf("!");
 				if (idx >= 0) {
-					let loadersRequest = request.substr(0, idx + 1);
+					let loadersRequest = request.slice(0, idx + 1);
 					let i;
 					for (
 						i = 0;
@@ -138,15 +145,11 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 						loadersPrefix += "!";
 					}
 					loadersRequest = loadersRequest
-						.substr(i)
+						.slice(i)
 						.replace(/!+$/, "")
 						.replace(/!!+/g, "!");
-					if (loadersRequest === "") {
-						loaders = [];
-					} else {
-						loaders = loadersRequest.split("!");
-					}
-					resource = request.substr(idx + 1);
+					loaders = loadersRequest === "" ? [] : loadersRequest.split("!");
+					resource = request.slice(idx + 1);
 				} else {
 					loaders = [];
 					resource = request;
@@ -159,7 +162,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 								resolveOptions || EMPTY_RESOLVE_OPTIONS,
 								"dependencyType",
 								dependencies[0].category
-						  )
+							)
 						: resolveOptions
 				);
 				const loaderResolver = this.resolverFactory.get("loader");
@@ -167,6 +170,15 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				asyncLib.parallel(
 					[
 						callback => {
+							const results = /** @type ResolveRequest[] */ ([]);
+							/**
+							 * @param {ResolveRequest} obj obj
+							 * @returns {void}
+							 */
+							const yield_ = obj => {
+								results.push(obj);
+							};
+
 							contextResolver.resolve(
 								{},
 								context,
@@ -174,11 +186,12 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 								{
 									fileDependencies,
 									missingDependencies,
-									contextDependencies
+									contextDependencies,
+									yield: yield_
 								},
-								(err, result) => {
+								err => {
 									if (err) return callback(err);
-									callback(null, result);
+									callback(null, results);
 								}
 							);
 						},
@@ -197,7 +210,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 										},
 										(err, result) => {
 											if (err) return callback(err);
-											callback(null, result);
+											callback(null, /** @type {string} */ (result));
 										}
 									);
 								},
@@ -213,15 +226,26 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 								contextDependencies
 							});
 						}
-
+						let [contextResult, loaderResult] =
+							/** @type {[ResolveRequest[], string[]]} */ (result);
+						if (contextResult.length > 1) {
+							const first = contextResult[0];
+							contextResult = contextResult.filter(r => r.path);
+							if (contextResult.length === 0) contextResult.push(first);
+						}
 						this.hooks.afterResolve.callAsync(
 							{
 								addon:
 									loadersPrefix +
-									result[1].join("!") +
-									(result[1].length > 0 ? "!" : ""),
-								resource: result[0],
+									loaderResult.join("!") +
+									(loaderResult.length > 0 ? "!" : ""),
+								resource:
+									contextResult.length > 1
+										? contextResult.map(r => r.path)
+										: contextResult[0].path,
 								resolveDependencies: this.resolveDependencies.bind(this),
+								resourceQuery: contextResult[0].query,
+								resourceFragment: contextResult[0].fragment,
 								...beforeResolveResult
 							},
 							(err, result) => {
@@ -274,30 +298,47 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			exclude,
 			referencedExports,
 			category,
-			typePrefix
+			typePrefix,
+			attributes
 		} = options;
 		if (!regExp || !resource) return callback(null, []);
 
-		const addDirectoryChecked = (directory, visited, callback) => {
-			fs.realpath(directory, (err, realPath) => {
+		/**
+		 * @param {string} ctx context
+		 * @param {string} directory directory
+		 * @param {Set<string>} visited visited
+		 * @param {ResolveDependenciesCallback} callback callback
+		 */
+		const addDirectoryChecked = (ctx, directory, visited, callback) => {
+			/** @type {NonNullable<InputFileSystem["realpath"]>} */
+			(fs.realpath)(directory, (err, _realPath) => {
 				if (err) return callback(err);
+				const realPath = /** @type {string} */ (_realPath);
 				if (visited.has(realPath)) return callback(null, []);
+				/** @type {Set<string> | undefined} */
 				let recursionStack;
 				addDirectory(
+					ctx,
 					directory,
-					(dir, callback) => {
+					(_, dir, callback) => {
 						if (recursionStack === undefined) {
 							recursionStack = new Set(visited);
 							recursionStack.add(realPath);
 						}
-						addDirectoryChecked(dir, recursionStack, callback);
+						addDirectoryChecked(ctx, dir, recursionStack, callback);
 					},
 					callback
 				);
 			});
 		};
 
-		const addDirectory = (directory, addSubDirectory, callback) => {
+		/**
+		 * @param {string} ctx context
+		 * @param {string} directory directory
+		 * @param {function(string, string, function(): void): void} addSubDirectory addSubDirectoryFn
+		 * @param {ResolveDependenciesCallback} callback callback
+		 */
+		const addDirectory = (ctx, directory, addSubDirectory, callback) => {
 			fs.readdir(directory, (err, files) => {
 				if (err) return callback(err);
 				const processedFiles = cmf.hooks.contextModuleFiles.call(
@@ -311,29 +352,29 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 						const subResource = join(fs, directory, segment);
 
 						if (!exclude || !subResource.match(exclude)) {
-							fs.stat(subResource, (err, stat) => {
+							fs.stat(subResource, (err, _stat) => {
 								if (err) {
 									if (err.code === "ENOENT") {
 										// ENOENT is ok here because the file may have been deleted between
 										// the readdir and stat calls.
 										return callback();
-									} else {
-										return callback(err);
 									}
+									return callback(err);
 								}
 
+								const stat = /** @type {IStats} */ (_stat);
+
 								if (stat.isDirectory()) {
 									if (!recursive) return callback();
-									addSubDirectory(subResource, callback);
+									addSubDirectory(ctx, subResource, callback);
 								} else if (
 									stat.isFile() &&
 									(!include || subResource.match(include))
 								) {
+									/** @type {{ context: string, request: string }} */
 									const obj = {
-										context: resource,
-										request:
-											"." +
-											subResource.substr(resource.length).replace(/\\/g, "/")
+										context: ctx,
+										request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}`
 									};
 
 									this.hooks.alternativeRequests.callAsync(
@@ -341,20 +382,29 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 										options,
 										(err, alternatives) => {
 											if (err) return callback(err);
-											alternatives = alternatives
-												.filter(obj => regExp.test(obj.request))
-												.map(obj => {
-													const dep = new ContextElementDependency(
-														obj.request + resourceQuery + resourceFragment,
-														obj.request,
-														typePrefix,
-														category,
-														referencedExports
-													);
-													dep.optional = true;
-													return dep;
-												});
-											callback(null, alternatives);
+											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,
+															/** @type {TODO} */
+															(obj.context),
+															attributes
+														);
+														dep.optional = true;
+														return dep;
+													})
+											);
 										}
 									);
 								} else {
@@ -382,12 +432,50 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			});
 		};
 
-		if (typeof fs.realpath === "function") {
-			addDirectoryChecked(resource, new Set(), callback);
+		/**
+		 * @param {string} ctx context
+		 * @param {string} dir dir
+		 * @param {ResolveDependenciesCallback} callback callback
+		 * @returns {void}
+		 */
+		const addSubDirectory = (ctx, dir, callback) =>
+			addDirectory(ctx, dir, addSubDirectory, callback);
+
+		/**
+		 * @param {string} resource resource
+		 * @param {ResolveDependenciesCallback} callback callback
+		 */
+		const visitResource = (resource, callback) => {
+			if (typeof fs.realpath === "function") {
+				addDirectoryChecked(resource, resource, new Set(), callback);
+			} else {
+				addDirectory(resource, resource, addSubDirectory, callback);
+			}
+		};
+
+		if (typeof resource === "string") {
+			visitResource(resource, callback);
 		} else {
-			const addSubDirectory = (dir, callback) =>
-				addDirectory(dir, addSubDirectory, callback);
-			addDirectory(resource, addSubDirectory, callback);
+			asyncLib.map(resource, visitResource, (err, _result) => {
+				if (err) return callback(err);
+				const result = /** @type {ContextElementDependency[][]} */ (_result);
+
+				// result dependencies should have unique userRequest
+				// ordered by resolve result
+				/** @type {Set<string>} */
+				const temp = new Set();
+				/** @type {ContextElementDependency[]} */
+				const res = [];
+				for (let i = 0; i < result.length; i++) {
+					const inner = result[i];
+					for (const el of inner) {
+						if (temp.has(el.userRequest)) continue;
+						res.push(el);
+						temp.add(el.userRequest);
+					}
+				}
+				callback(null, res);
+			});
 		}
 	}
 };

package/lib/ContextReplacementPlugin.js

@@ -8,7 +8,16 @@
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 const { join } = require("./util/fs");
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
 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 {RegExp=} newContentRegExp A regular expression that determines which files will be selected
+	 */
 	constructor(
 		resourceRegExp,
 		newContentResource,
@@ -49,6 +58,11 @@ class ContextReplacementPlugin {
 		}
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const resourceRegExp = this.resourceRegExp;
 		const newContentCallback = this.newContentCallback;
@@ -91,7 +105,7 @@ class ContextReplacementPlugin {
 							result.resource = newContentResource;
 						} else {
 							result.resource = join(
-								compiler.inputFileSystem,
+								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
 								result.resource,
 								newContentResource
 							);
@@ -119,7 +133,7 @@ class ContextReplacementPlugin {
 						) {
 							// When the function changed it to an relative path
 							result.resource = join(
-								compiler.inputFileSystem,
+								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
 								origResource,
 								result.resource
 							);
@@ -140,14 +154,15 @@ const createResolveDependenciesFromContextMap = createContextMap => {
 	const resolveDependenciesFromContextMap = (fs, options, callback) => {
 		createContextMap(fs, (err, map) => {
 			if (err) return callback(err);
-			const dependencies = Object.keys(map).map(key => {
-				return new ContextElementDependency(
-					map[key] + options.resourceQuery + options.resourceFragment,
-					key,
-					options.category,
-					options.referencedExports
-				);
-			});
+			const dependencies = Object.keys(map).map(
+				key =>
+					new ContextElementDependency(
+						map[key] + options.resourceQuery + options.resourceFragment,
+						key,
+						options.category,
+						options.referencedExports
+					)
+			);
 			callback(null, dependencies);
 		});
 	};

package/lib/CssModule.js

@@ -0,0 +1,166 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Krasnoyarov @alexander-akait
+*/
+
+"use strict";
+
+const NormalModule = require("./NormalModule");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {string|undefined} CssLayer */
+/** @typedef {string|undefined} Supports */
+/** @typedef {string|undefined} Media */
+/** @typedef {[CssLayer?, Supports?, Media?]} InheritanceItem */
+/** @typedef {Array<InheritanceItem>} Inheritance */
+
+/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer|null, supports: Supports|null, media: Media|null, inheritance: Inheritance|null }} CSSModuleCreateData */
+
+class CssModule extends NormalModule {
+	/**
+	 * @param {CSSModuleCreateData} options options object
+	 */
+	constructor(options) {
+		super(options);
+
+		// Avoid override `layer` for `Module` class, because it is a feature to run module in specific layer
+		this.cssLayer = options.cssLayer;
+		this.supports = options.supports;
+		this.media = options.media;
+		this.inheritance = options.inheritance;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		let identifier = super.identifier();
+
+		if (this.cssLayer) {
+			identifier += `|${this.cssLayer}`;
+		}
+
+		if (this.supports) {
+			identifier += `|${this.supports}`;
+		}
+
+		if (this.media) {
+			identifier += `|${this.media}`;
+		}
+
+		if (this.inheritance) {
+			const inheritance = this.inheritance.map(
+				(item, index) =>
+					`inheritance_${index}|${item[0] || ""}|${item[1] || ""}|${
+						item[2] || ""
+					}`
+			);
+
+			identifier += `|${inheritance.join("|")}`;
+		}
+
+		return identifier;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		const readableIdentifier = super.readableIdentifier(requestShortener);
+
+		let identifier = `css ${readableIdentifier}`;
+
+		if (this.cssLayer) {
+			identifier += ` (layer: ${this.cssLayer})`;
+		}
+
+		if (this.supports) {
+			identifier += ` (supports: ${this.supports})`;
+		}
+
+		if (this.media) {
+			identifier += ` (media: ${this.media})`;
+		}
+
+		return identifier;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {CssModule} */ (module);
+		this.cssLayer = m.cssLayer;
+		this.supports = m.supports;
+		this.media = m.media;
+		this.inheritance = m.inheritance;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.cssLayer);
+		write(this.supports);
+		write(this.media);
+		write(this.inheritance);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {CssModule} the deserialized object
+	 */
+	static deserialize(context) {
+		const obj = new CssModule({
+			// will be deserialized by Module
+			layer: null,
+			type: "",
+			// will be filled by updateCacheModule
+			resource: "",
+			context: "",
+			request: null,
+			userRequest: null,
+			rawRequest: null,
+			loaders: null,
+			matchResource: null,
+			parser: null,
+			parserOptions: null,
+			generator: null,
+			generatorOptions: null,
+			resolveOptions: null,
+			cssLayer: null,
+			supports: null,
+			media: null,
+			inheritance: null
+		});
+		obj.deserialize(context);
+		return obj;
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.cssLayer = read();
+		this.supports = read();
+		this.media = read();
+		this.inheritance = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(CssModule, "webpack/lib/CssModule");
+
+module.exports = CssModule;