webpack 5.59.0 → 5.94.0

package/lib/sharing/ConsumeSharedModule.js

@@ -8,6 +8,9 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const {
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
@@ -22,21 +25,24 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
 
 /**
- * @typedef {Object} ConsumeOptions
+ * @typedef {object} ConsumeOptions
  * @property {string=} import fallback request
  * @property {string=} importResolved resolved fallback request
  * @property {string} shareKey global share key
  * @property {string} shareScope share scope
  * @property {SemVerRange | false | undefined} requiredVersion version requirement
- * @property {string} packageName package name to determine required version automatically
+ * @property {string=} packageName package name to determine required version automatically
  * @property {boolean} strictVersion don't use shared version even if version isn't valid
  * @property {boolean} singleton use single global version
  * @property {boolean} eager include the fallback module in a sync way
@@ -50,7 +56,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {ConsumeOptions} options consume options
 	 */
 	constructor(context, options) {
-		super("consume-shared-module", context);
+		super(WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE, context);
 		this.options = options;
 	}
 
@@ -67,7 +73,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
-		return `consume-shared-module|${shareScope}|${shareKey}|${
+		return `${WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE}|${shareScope}|${shareKey}|${
 			requiredVersion && rangeToString(requiredVersion)
 		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
 	}
@@ -101,14 +107,16 @@ class ConsumeSharedModule extends Module {
 	 */
 	libIdent(options) {
 		const { shareKey, shareScope, import: request } = this.options;
-		return `webpack/sharing/consume/${shareScope}/${shareKey}${
+		return `${
+			this.layer ? `(${this.layer})/` : ""
+		}webpack/sharing/consume/${shareScope}/${shareKey}${
 			request ? `/${request}` : ""
 		}`;
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -140,7 +148,7 @@ class ConsumeSharedModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -199,22 +207,31 @@ class ConsumeSharedModule extends Module {
 				});
 			}
 		}
-		let fn = "load";
-		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
+
+		const args = [
+			JSON.stringify(shareScope),
+			JSON.stringify(shareKey),
+			JSON.stringify(eager)
+		];
 		if (requiredVersion) {
-			if (strictVersion) {
-				fn += "Strict";
-			}
-			if (singleton) {
-				fn += "Singleton";
-			}
 			args.push(stringifyHoley(requiredVersion));
-			fn += "VersionCheck";
 		}
 		if (fallbackCode) {
-			fn += "Fallback";
 			args.push(fallbackCode);
 		}
+
+		let fn;
+
+		if (requiredVersion) {
+			if (strictVersion) {
+				fn = singleton ? "loadStrictSingletonVersion" : "loadStrictVersion";
+			} else {
+				fn = singleton ? "loadSingletonVersion" : "loadVersion";
+			}
+		} else {
+			fn = singleton ? "loadSingleton" : "load";
+		}
+
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));
@@ -224,12 +241,18 @@ class ConsumeSharedModule extends Module {
 		};
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.options);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.options = read();

package/lib/sharing/ConsumeSharedPlugin.js

@@ -27,7 +27,9 @@ const {
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
+/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
 /** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
+/** @typedef {import("./utils").DescriptionFile} DescriptionFile */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check.js"),
@@ -57,10 +59,10 @@ class ConsumeSharedPlugin {
 			(item, key) => {
 				if (Array.isArray(item)) throw new Error("Unexpected array in options");
 				/** @type {ConsumeOptions} */
-				let result =
+				const result =
 					item === key || !isRequiredVersion(item)
 						? // item is a request/key
-						  {
+							{
 								import: key,
 								shareScope: options.shareScope || "default",
 								shareKey: key,
@@ -69,10 +71,10 @@ class ConsumeSharedPlugin {
 								strictVersion: false,
 								singleton: false,
 								eager: false
-						  }
+							}
 						: // key is a request/key
-						  // item is a version
-						  {
+							// item is a version
+							{
 								import: key,
 								shareScope: options.shareScope || "default",
 								shareKey: key,
@@ -81,7 +83,7 @@ class ConsumeSharedPlugin {
 								packageName: undefined,
 								singleton: false,
 								eager: false
-						  };
+							};
 				return result;
 			},
 			(item, key) => ({
@@ -97,8 +99,8 @@ class ConsumeSharedPlugin {
 						? item.strictVersion
 						: item.import !== false && !item.singleton,
 				packageName: item.packageName,
-				singleton: !!item.singleton,
-				eager: !!item.eager
+				singleton: Boolean(item.singleton),
+				eager: Boolean(item.eager)
 			})
 		);
 	}
@@ -117,7 +119,12 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
-				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let unresolvedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let resolvedConsumes;
+				/** @type {Map<string, ConsumeOptions>} */
+				let prefixedConsumes;
 				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
 					({ resolved, unresolved, prefixed }) => {
 						resolvedConsumes = resolved;
@@ -138,6 +145,9 @@ class ConsumeSharedPlugin {
 				 * @returns {Promise<ConsumeSharedModule>} create module
 				 */
 				const createConsumeSharedModule = (context, request, config) => {
+					/**
+					 * @param {string} details details
+					 */
 					const requiredVersionWarning = details => {
 						const error = new WebpackError(
 							`No required version specified and unable to automatically determine one. ${details}`
@@ -149,106 +159,127 @@ class ConsumeSharedPlugin {
 						config.import &&
 						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
 					return Promise.all([
-						new Promise(resolve => {
-							if (!config.import) return resolve();
-							const resolveContext = {
-								/** @type {LazySet<string>} */
-								fileDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								contextDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								missingDependencies: new LazySet()
-							};
-							resolver.resolve(
-								{},
-								directFallback ? compiler.context : context,
-								config.import,
-								resolveContext,
-								(err, result) => {
-									compilation.contextDependencies.addAll(
-										resolveContext.contextDependencies
-									);
-									compilation.fileDependencies.addAll(
-										resolveContext.fileDependencies
-									);
-									compilation.missingDependencies.addAll(
-										resolveContext.missingDependencies
-									);
-									if (err) {
-										compilation.errors.push(
-											new ModuleNotFoundError(null, err, {
-												name: `resolving fallback for shared module ${request}`
-											})
-										);
-										return resolve();
-									}
-									resolve(result);
+						new Promise(
+							/**
+							 * @param {(value?: string) => void} resolve resolve
+							 */
+							resolve => {
+								if (!config.import) {
+									resolve();
+									return;
 								}
-							);
-						}),
-						new Promise(resolve => {
-							if (config.requiredVersion !== undefined)
-								return resolve(config.requiredVersion);
-							let packageName = config.packageName;
-							if (packageName === undefined) {
-								if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
-									// For relative or absolute requests we don't automatically use a packageName.
-									// If wished one can specify one with the packageName option.
-									return resolve();
-								}
-								const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
-								if (!match) {
-									requiredVersionWarning(
-										"Unable to extract the package name from request."
-									);
-									return resolve();
-								}
-								packageName = match[0];
-							}
-
-							getDescriptionFile(
-								compilation.inputFileSystem,
-								context,
-								["package.json"],
-								(err, result) => {
-									if (err) {
-										requiredVersionWarning(
-											`Unable to read description file: ${err}`
+								const resolveContext = {
+									/** @type {LazySet<string>} */
+									fileDependencies: new LazySet(),
+									/** @type {LazySet<string>} */
+									contextDependencies: new LazySet(),
+									/** @type {LazySet<string>} */
+									missingDependencies: new LazySet()
+								};
+								resolver.resolve(
+									{},
+									directFallback ? compiler.context : context,
+									config.import,
+									resolveContext,
+									(err, result) => {
+										compilation.contextDependencies.addAll(
+											resolveContext.contextDependencies
 										);
-										return resolve();
-									}
-									const { data, path: descriptionPath } = result;
-									if (!data) {
-										requiredVersionWarning(
-											`Unable to find description file in ${context}.`
+										compilation.fileDependencies.addAll(
+											resolveContext.fileDependencies
+										);
+										compilation.missingDependencies.addAll(
+											resolveContext.missingDependencies
 										);
-										return resolve();
+										if (err) {
+											compilation.errors.push(
+												new ModuleNotFoundError(null, err, {
+													name: `resolving fallback for shared module ${request}`
+												})
+											);
+											return resolve();
+										}
+										resolve(/** @type {string} */ (result));
+									}
+								);
+							}
+						),
+						new Promise(
+							/**
+							 * @param {(value?: SemVerRange) => void} resolve resolve
+							 */
+							resolve => {
+								if (config.requiredVersion !== undefined) {
+									resolve(/** @type {SemVerRange} */ (config.requiredVersion));
+									return;
+								}
+								let packageName = config.packageName;
+								if (packageName === undefined) {
+									if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
+										// For relative or absolute requests we don't automatically use a packageName.
+										// If wished one can specify one with the packageName option.
+										resolve();
+										return;
 									}
-									const requiredVersion = getRequiredVersionFromDescriptionFile(
-										data,
-										packageName
-									);
-									if (typeof requiredVersion !== "string") {
+									const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
+									if (!match) {
 										requiredVersionWarning(
-											`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
+											"Unable to extract the package name from request."
 										);
-										return resolve();
+										resolve();
+										return;
 									}
-									resolve(parseRange(requiredVersion));
+									packageName = match[0];
 								}
-							);
-						})
-					]).then(([importResolved, requiredVersion]) => {
-						return new ConsumeSharedModule(
-							directFallback ? compiler.context : context,
-							{
-								...config,
-								importResolved,
-								import: importResolved ? config.import : undefined,
-								requiredVersion
+
+								getDescriptionFile(
+									compilation.inputFileSystem,
+									context,
+									["package.json"],
+									(err, result) => {
+										if (err) {
+											requiredVersionWarning(
+												`Unable to read description file: ${err}`
+											);
+											return resolve();
+										}
+										const { data, path: descriptionPath } =
+											/** @type {DescriptionFile} */ (result);
+										if (!data) {
+											requiredVersionWarning(
+												`Unable to find description file in ${context}.`
+											);
+											return resolve();
+										}
+										if (data.name === packageName) {
+											// Package self-referencing
+											return resolve();
+										}
+										const requiredVersion =
+											getRequiredVersionFromDescriptionFile(data, packageName);
+										if (typeof requiredVersion !== "string") {
+											requiredVersionWarning(
+												`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
+											);
+											return resolve();
+										}
+										resolve(parseRange(requiredVersion));
+									}
+								);
 							}
-						);
-					});
+						)
+					]).then(
+						([importResolved, requiredVersion]) =>
+							new ConsumeSharedModule(
+								directFallback ? compiler.context : context,
+								{
+									...config,
+									importResolved,
+									import: importResolved ? config.import : undefined,
+									requiredVersion
+								}
+							)
+					);
 				};
 
 				normalModuleFactory.hooks.factorize.tapPromise(
@@ -289,9 +320,15 @@ class ConsumeSharedPlugin {
 						) {
 							return Promise.resolve();
 						}
-						const options = resolvedConsumes.get(resource);
+						const options = resolvedConsumes.get(
+							/** @type {string} */ (resource)
+						);
 						if (options !== undefined) {
-							return createConsumeSharedModule(context, resource, options);
+							return createConsumeSharedModule(
+								context,
+								/** @type {string} */ (resource),
+								options
+							);
 						}
 						return Promise.resolve();
 					}