webpack 5.97.1 → 5.104.1

package/lib/serialization/SerializerMiddleware.js

@@ -9,20 +9,33 @@ const memoize = require("../util/memoize");
 const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
+/** @typedef {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, Record<string, EXPECTED_ANY>>} LazyTarget */
+/** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
+
+/**
+ * @template InputValue
+ * @template OutputValue
+ * @template {LazyTarget} InternalLazyTarget
+ * @template {LazyOptions | undefined} InternalLazyOptions
+ * @typedef {(() => InputValue | Promise<InputValue>) & Partial<{ [LAZY_TARGET]: InternalLazyTarget, options: InternalLazyOptions, [LAZY_SERIALIZED_VALUE]?: OutputValue | LazyFunction<OutputValue, InputValue, InternalLazyTarget, InternalLazyOptions> | undefined }>} LazyFunction
+ */
+
 /**
  * @template DeserializedType
  * @template SerializedType
+ * @template Context
  */
 class SerializerMiddleware {
 	/* istanbul ignore next */
 	/**
 	 * @abstract
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -30,34 +43,47 @@ class SerializerMiddleware {
 	/**
 	 * @abstract
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {any | function(): Promise<any> | any} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {object=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {function(): Promise<any> | any} lazy function
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {TLazyInputValue | (() => TLazyInputValue)} value contained value or function to value
+	 * @param {TLazyTarget} target target middleware
+	 * @param {TLazyOptions=} options lazy options
+	 * @param {TLazyOutputValue=} serializedValue serialized value
+	 * @returns {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy function
 	 */
-	static createLazy(value, target, options = {}, serializedValue = undefined) {
+	static createLazy(
+		value,
+		target,
+		options = /** @type {TLazyOptions} */ ({}),
+		serializedValue = undefined
+	) {
 		if (SerializerMiddleware.isLazy(value, target)) return value;
-		const fn = typeof value === "function" ? value : () => value;
+		const fn =
+			/** @type {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} */
+			(typeof value === "function" ? value : () => value);
 		fn[LAZY_TARGET] = target;
-		/** @type {any} */ (fn).options = options;
+		fn.options = options;
 		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
 		return fn;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {SerializerMiddleware<any, any>=} target target middleware
-	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 * @template {LazyTarget} TLazyTarget
+	 * @param {EXPECTED_ANY} fn lazy function
+	 * @param {TLazyTarget=} target target middleware
+	 * @returns {fn is LazyFunction<EXPECTED_ANY, EXPECTED_ANY, TLazyTarget, EXPECTED_ANY>} true, when fn is a lazy function (optionally of that target)
 	 */
 	static isLazy(fn, target) {
 		if (typeof fn !== "function") return false;
@@ -66,17 +92,25 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object | undefined} options
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
+	 * @returns {LazyOptions | undefined} options
 	 */
 	static getLazyOptions(fn) {
 		if (typeof fn !== "function") return;
-		return /** @type {any} */ (fn).options;
+		return fn.options;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {any | undefined} serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions> | EXPECTED_ANY} fn lazy function
+	 * @returns {TLazyOutputValue | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
 		if (typeof fn !== "function") return;
@@ -84,8 +118,12 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {any} value serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
+	 * @param {TLazyOutputValue} value serialized value
 	 * @returns {void}
 	 */
 	static setLazySerializedValue(fn, value) {
@@ -93,60 +131,94 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} serialize serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @template TLazyInputValue DeserializedValue
+	 * @template TLazyOutputValue SerializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(value: TLazyInputValue) => TLazyOutputValue} serialize serialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static serializeLazy(lazy, serialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => data && serialize(data));
-			}
-			return serialize(r);
-		});
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */
+			(
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then((data) => data && serialize(data))
+						);
+					}
+					return serialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		lazy[LAZY_SERIALIZED_VALUE] = fn;
 		return fn;
 	}
 
 	/**
-	 * @template T
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(T): Promise<T> | T} deserialize deserialize function
-	 * @returns {function(): Promise<T> | T} new lazy
+	 * @template TLazyInputValue SerializedValue
+	 * @template TLazyOutputValue DeserializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(data: TLazyInputValue) => TLazyOutputValue} deserialize deserialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static deserializeLazy(lazy, deserialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => deserialize(data));
-			}
-			return deserialize(r);
-		});
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */ (
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then((data) => deserialize(data))
+						);
+					}
+					return deserialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		fn[LAZY_SERIALIZED_VALUE] = lazy;
 		return fn;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} lazy lazy function
+	 * @returns {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} new lazy
 	 */
 	static unMemoizeLazy(lazy) {
 		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
+		/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
 		const fn = () => {
 			throw new Error(
 				"A lazy value that has been unmemorized can't be called again"
 			);
 		};
 		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
+			/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
+			(lazy[LAZY_SERIALIZED_VALUE])
 		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		fn.options = /** @type {any} */ (lazy).options;
+		fn.options = lazy.options;
 		return fn;
 	}
 }

package/lib/serialization/SingleItemMiddleware.js

@@ -6,16 +6,18 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
+/** @typedef {EXPECTED_ANY} DeserializedType */
+/** @typedef {EXPECTED_ANY[]} SerializedType */
+/** @typedef {EXPECTED_OBJECT} Context */
+
 /**
- * @typedef {any} DeserializedType
- * @typedef {any[]} SerializedType
- * @extends {SerializerMiddleware<any, any[]>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class SingleItemMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		return [data];
@@ -23,8 +25,8 @@ class SingleItemMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		return data[0];

package/lib/serialization/types.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {undefined | null | number | string | boolean | Buffer | object | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
+/** @typedef {undefined | null | number | bigint | string | boolean | Buffer | EXPECTED_OBJECT | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
 
 /** @typedef {undefined | null | number | bigint | string | boolean | Buffer | (() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
 

package/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypesConstants");
+const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -17,19 +17,19 @@ const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @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 */
@@ -102,7 +102,7 @@ class ConsumeSharedModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		const { shareKey, shareScope, import: request } = this.options;
@@ -115,7 +115,7 @@ class ConsumeSharedModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -127,7 +127,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -175,7 +175,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
-	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
+	codeGeneration({ chunkGraph, runtimeTemplate }) {
 		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
 		const {
 			shareScope,

package/lib/sharing/ConsumeSharedPlugin.js

@@ -18,13 +18,13 @@ const ConsumeSharedRuntimeModule = require("./ConsumeSharedRuntimeModule");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 const { resolveMatchedConfigs } = require("./resolveMatchedConfigs");
 const {
-	isRequiredVersion,
 	getDescriptionFile,
-	getRequiredVersionFromDescriptionFile
+	getRequiredVersionFromDescriptionFile,
+	isRequiredVersion
 } = require("./utils");
 
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
@@ -32,7 +32,7 @@ const {
 /** @typedef {import("./utils").DescriptionFile} DescriptionFile */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check.js"),
+	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check"),
 	() => require("../../schemas/plugins/sharing/ConsumeSharedPlugin.json"),
 	{
 		name: "Consume Shared Plugin",
@@ -119,11 +119,13 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @typedef {Map<string, ConsumeOptions>} Consumes */
+
+				/** @type {Consumes} */
 				let unresolvedConsumes;
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @type {Consumes} */
 				let resolvedConsumes;
-				/** @type {Map<string, ConsumeOptions>} */
+				/** @type {Consumes} */
 				let prefixedConsumes;
 				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
 					({ resolved, unresolved, prefixed }) => {
@@ -148,7 +150,7 @@ class ConsumeSharedPlugin {
 					/**
 					 * @param {string} details details
 					 */
-					const requiredVersionWarning = details => {
+					const requiredVersionWarning = (details) => {
 						const error = new WebpackError(
 							`No required version specified and unable to automatically determine one. ${details}`
 						);
@@ -163,17 +165,15 @@ class ConsumeSharedPlugin {
 							/**
 							 * @param {(value?: string) => void} resolve resolve
 							 */
-							resolve => {
+							(resolve) => {
 								if (!config.import) {
 									resolve();
 									return;
 								}
+								/** @typedef {ResolveContext} */
 								const resolveContext = {
-									/** @type {LazySet<string>} */
 									fileDependencies: new LazySet(),
-									/** @type {LazySet<string>} */
 									contextDependencies: new LazySet(),
-									/** @type {LazySet<string>} */
 									missingDependencies: new LazySet()
 								};
 								resolver.resolve(
@@ -208,7 +208,7 @@ class ConsumeSharedPlugin {
 							/**
 							 * @param {(value?: SemVerRange) => void} resolve resolve
 							 */
-							resolve => {
+							(resolve) => {
 								if (config.requiredVersion !== undefined) {
 									resolve(/** @type {SemVerRange} */ (config.requiredVersion));
 									return;
@@ -276,7 +276,7 @@ class ConsumeSharedPlugin {
 
 										resolve();
 									},
-									result => {
+									(result) => {
 										if (!result) return false;
 										const maybeRequiredVersion =
 											getRequiredVersionFromDescriptionFile(

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -10,9 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 const {
 	parseVersionRuntimeCode,
-	versionLtRuntimeCode,
 	rangeToStringRuntimeCode,
-	satisfyRuntimeCode
+	satisfyRuntimeCode,
+	versionLtRuntimeCode
 } = require("../util/semver");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -23,7 +23,7 @@ const {
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
 	/**
@@ -40,17 +40,20 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
-		const { runtimeTemplate, codeGenerationResults } = compilation;
-		/** @type {Record<ChunkId, (string | number)[]>} */
+		const codeGenerationResults =
+			/** @type {CodeGenerationResults} */
+			(compilation.codeGenerationResults);
+		const { runtimeTemplate } = compilation;
+		/** @type {Record<ChunkId, ModuleId[]>} */
 		const chunkToModuleMapping = {};
-		/** @type {Map<string | number, Source>} */
+		/** @type {Map<ModuleId, Source>} */
 		const moduleIdToSourceMapping = new Map();
-		/** @type {(string | number)[]} */
+		/** @type {ModuleId[]} */
 		const initialConsumes = [];
 		/**
 		 * @param {Iterable<Module>} modules modules
 		 * @param {Chunk} chunk the chunk
-		 * @param {(string | number)[]} list list of ids
+		 * @param {ModuleId[]} list list of ids
 		 */
 		const addModules = (modules, chunk, list) => {
 			for (const m of modules) {

package/lib/sharing/ProvideSharedModule.js

@@ -7,28 +7,26 @@
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { SHARED_INIT_TYPES } = require("../ModuleSourceTypesConstants");
+const { SHARED_INIT_TYPES } = require("../ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_PROVIDE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @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 */
 
 class ProvideSharedModule extends Module {
@@ -67,7 +65,7 @@ class ProvideSharedModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
@@ -77,7 +75,7 @@ class ProvideSharedModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -89,7 +87,7 @@ class ProvideSharedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -130,7 +128,7 @@ class ProvideSharedModule extends Module {
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+	codeGeneration({ runtimeTemplate, chunkGraph }) {
 		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
 		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
 			this._version || "0"

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -8,18 +8,20 @@
 const ModuleFactory = require("../ModuleFactory");
 const ProvideSharedModule = require("./ProvideSharedModule");
 
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
 
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
-		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
+		const dep =
+			/** @type {ProvideSharedDependency} */
+			(data.dependencies[0]);
 		callback(null, {
 			module: new ProvideSharedModule(
 				dep.shareScope,