webpack 5.104.1 → 5.105.0

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -17,11 +17,12 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
  * @returns {string} mode
  */
 function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
-	if (exportsType === "namespace") return `/* ${exportsType} */ 0`;
-	if (exportsType === "default-only") return `/* ${exportsType} */ 1`;
+	// number is from createFakeNamespaceObject mode ^ 1
+	if (exportsType === "namespace") return `/* ${exportsType} */ 8`;
+	if (exportsType === "default-only") return `/* ${exportsType} */ 0`;
 	if (exportsType === "default-with-named") return `/* ${exportsType} */ 2`;
-	if (exportsType === "dynamic") return `/* ${exportsType} */ 3`;
-	return "";
+	if (exportsType === "dynamic") return `/* ${exportsType} */ 6`;
+	throw new Error(`Unknown exports type: ${exportsType}`);
 }
 
 /**
@@ -52,6 +53,7 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 	 */
 	constructor(hasAsyncRuntime) {
 		super("make optimized deferred namespace object");
+		/** @type {boolean} */
 		this.hasAsyncRuntime = hasAsyncRuntime;
 	}
 
@@ -66,10 +68,6 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 			// Note: must be a function (not arrow), because this is used in body!
 			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
 			Template.indent([
-				"// mode: 0 => namespace (esm)",
-				"// mode: 1 => default-only (esm strict cjs)",
-				"// mode: 2 => default-with-named (esm-cjs compat)",
-				"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
 				"var r = this;",
 				hasAsync ? "var isAsync = asyncDeps && asyncDeps.length;" : "",
 				"var obj = {",
@@ -83,7 +81,7 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 						// if exportsType is "namespace" we can generate the most optimized code,
 						// on the second access, we can avoid trigger the getter.
 						// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
-						'if(mode == 0 || (mode == 3 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
+						'if(mode & 8 || (mode & 4 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
 						"return exports;"
 					]),
 					"}"
@@ -120,11 +118,6 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			? "init?.();"
 			: "if (init) init();";
 		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
-			"// mode: 0 => namespace (esm)",
-			"// mode: 1 => default-only (esm strict cjs)",
-			"// mode: 2 => default-with-named (esm-cjs compat)",
-			"// mode: 3 => dynamic (if exports has __esModule, then esm, otherwise default-with-named)",
-			"",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
 			"if (cachedModule && cachedModule.error === undefined) {",
 			Template.indent([
@@ -132,10 +125,8 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				hasAsync
 					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
 					: "",
-				"if (mode == 0) return exports;",
-				`if (mode == 1) return ${RuntimeGlobals.createFakeNamespaceObject}(exports);`,
-				`if (mode == 2) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 2);`,
-				`if (mode == 3) return ${RuntimeGlobals.createFakeNamespaceObject}(exports, 6);` // 2 | 4
+				"if (mode & 8) return exports;",
+				`return ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
 			]),
 			"}",
 			"",
@@ -145,7 +136,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
 					: "",
 				"init = null;",
-				"if (mode == 0 || mode == 3 && ns.__esModule && typeof ns === 'object') {",
+				"if (mode & 8 || mode & 4 && ns.__esModule && typeof ns === 'object') {",
 				Template.indent([
 					"delete handler.defineProperty;",
 					"delete handler.deleteProperty;",
@@ -155,17 +146,9 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					"delete handler.ownKeys;",
 					"delete handler.getOwnPropertyDescriptor;"
 				]),
-				"} else if (mode == 1) {",
-				Template.indent([
-					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns);`
-				]),
-				"} else if (mode == 2) {",
-				Template.indent([
-					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 2);`
-				]),
-				"} else if (mode == 3) {",
+				"} else {",
 				Template.indent([
-					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, 6);`
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, mode);`
 				]),
 				"}"
 			])};`,
@@ -211,14 +194,14 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
 					"switch (name) {",
 					Template.indent([
-						'case "__esModule": return { value: true, configurable: !!mode };',
-						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !!mode };',
+						'case "__esModule": return { value: true, configurable: !(mode & 8) };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !(mode & 8) };',
 						'case "then": return undefined;'
 					]),
 					"}",
 					init,
 					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
-					'if (mode == 2 && name == "default" && !desc) {',
+					'if (mode & 2 && name == "default" && !desc) {',
 					Template.indent("desc = { value: ns, configurable: true };"),
 					"}",
 					"return desc;"

package/lib/runtime/PublicPathRuntimeModule.js

@@ -16,6 +16,7 @@ class PublicPathRuntimeModule extends RuntimeModule {
 	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
+		/** @type {PublicPath} */
 		this.publicPath = publicPath;
 	}
 

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -25,7 +25,9 @@ class StartupChunkDependenciesPlugin {
 	 * @param {Options} options options
 	 */
 	constructor(options) {
+		/** @type {ChunkLoadingType} */
 		this.chunkLoading = options.chunkLoading;
+		/** @type {boolean} */
 		this.asyncChunkLoading =
 			typeof options.asyncChunkLoading === "boolean"
 				? options.asyncChunkLoading

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -19,6 +19,7 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	 */
 	constructor(asyncChunkLoading) {
 		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
+		/** @type {boolean} */
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -15,6 +15,7 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 	 */
 	constructor(asyncChunkLoading) {
 		super("startup entrypoint");
+		/** @type {boolean} */
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 

package/lib/schemes/HttpUriPlugin.js

@@ -36,12 +36,20 @@ const getHttps = memoize(() => require("https"));
 
 const MAX_REDIRECTS = 5;
 
+/** @typedef {(url: URL, requestOptions: RequestOptions, callback: (incomingMessage: IncomingMessage) => void) => EventEmitter} Fetch */
+
+/**
+ * @typedef {object} EventsMap
+ * @property {[Error]} error
+ */
+
 /**
  * @param {typeof import("http") | typeof import("https")} request request
  * @param {string | URL | undefined} proxy proxy
- * @returns {(url: URL, requestOptions: RequestOptions, callback: (incomingMessage: IncomingMessage) => void) => EventEmitter} fn
+ * @returns {Fetch} fn
  */
 const proxyFetch = (request, proxy) => (url, options, callback) => {
+	/** @type {EventEmitter<EventsMap>} */
 	const eventEmitter = new EventEmitter();
 
 	/**
@@ -104,9 +112,7 @@ const validate = createSchemaValidation(
  * @returns {string} safe path
  */
 const toSafePath = (str) =>
-	str
-		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
-		.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	str.replace(/^[^a-z0-9]+|[^a-z0-9]+$/gi, "").replace(/[^a-z0-9._-]+/gi, "_");
 
 /**
  * @param {Buffer} content content
@@ -454,6 +460,9 @@ class HttpUriPlugin {
 	apply(compiler) {
 		const proxy =
 			this._proxy || process.env.http_proxy || process.env.HTTP_PROXY;
+		/**
+		 * @type {{ scheme: "http" | "https", fetch: Fetch }[]}
+		 */
 		const schemes = [
 			{
 				scheme: "http",
@@ -660,6 +669,7 @@ class HttpUriPlugin {
 					 * @returns {string} absolute, validated redirect target
 					 */
 					const validateRedirectLocation = (location, base) => {
+						/** @type {URL} */
 						let nextUrl;
 						try {
 							nextUrl = new URL(location, base);
@@ -707,6 +717,7 @@ class HttpUriPlugin {
 
 							if ("location" in result) {
 								// Validate redirect target before following
+								/** @type {string} */
 								let absolute;
 								try {
 									absolute = validateRedirectLocation(result.location, url);
@@ -845,6 +856,7 @@ class HttpUriPlugin {
 								res.statusCode >= 301 &&
 								res.statusCode <= 308
 							) {
+								/** @type {string} */
 								let absolute;
 								try {
 									absolute = validateRedirectLocation(location, url);
@@ -891,9 +903,15 @@ class HttpUriPlugin {
 								stream = stream.pipe(createInflate());
 							}
 
-							stream.on("data", (chunk) => {
-								bufferArr.push(chunk);
-							});
+							stream.on(
+								"data",
+								/**
+								 * @param {Buffer} chunk chunk
+								 */
+								(chunk) => {
+									bufferArr.push(chunk);
+								}
+							);
 
 							stream.on("end", () => {
 								if (!res.complete) {
@@ -953,6 +971,7 @@ class HttpUriPlugin {
 					 * @returns {boolean} true when allowed, otherwise false
 					 */
 					const isAllowed = (uri) => {
+						/** @type {URL} */
 						let parsedUri;
 						try {
 							// Parse the URI to prevent userinfo bypass attacks
@@ -963,6 +982,7 @@ class HttpUriPlugin {
 						}
 						for (const allowed of allowedUris) {
 							if (typeof allowed === "string") {
+								/** @type {URL} */
 								let parsedAllowed;
 								try {
 									parsedAllowed = new URL(allowed);

package/lib/schemes/VirtualUrlPlugin.js

@@ -58,17 +58,19 @@ function normalizeModule(virtualConfig) {
 	return virtualConfig;
 }
 
+/** @typedef {{ [key: string]: VirtualModuleConfig }} NormalizedModules */
+
 /**
  * Normalizes all virtual modules with the given scheme
  * @param {VirtualModules} virtualConfigs The virtual modules to normalize
  * @param {string} scheme The URL scheme to use
- * @returns {{ [key: string]: VirtualModuleConfig }} The normalized virtual modules
+ * @returns {NormalizedModules} The normalized virtual modules
  */
 function normalizeModules(virtualConfigs, scheme) {
 	return Object.keys(virtualConfigs).reduce((pre, id) => {
 		pre[toVid(id, scheme)] = normalizeModule(virtualConfigs[id]);
 		return pre;
-	}, /** @type {{ [key: string]: VirtualModuleConfig }} */ ({}));
+	}, /** @type {NormalizedModules} */ ({}));
 }
 
 /**
@@ -105,7 +107,9 @@ class VirtualUrlPlugin {
 	 * @param {string=} scheme The URL scheme to use
 	 */
 	constructor(modules, scheme) {
+		/** @type {string} */
 		this.scheme = scheme || DEFAULT_SCHEME;
+		/** @type {NormalizedModules} */
 		this.modules = normalizeModules(modules, this.scheme);
 	}
 
@@ -135,6 +139,7 @@ class VirtualUrlPlugin {
 						const type = virtualConfig.type;
 						resourceData.path = path + type;
 						resourceData.resource = path;
+						resourceData.context = compiler.context;
 
 						if (virtualConfig.version) {
 							const cacheKey = toCacheKey(resourceData.resource, scheme);

package/lib/serialization/BinaryMiddleware.js

@@ -313,6 +313,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 					/** @type {number[]} */
 					const lengths = [];
 					for (const item of serializedData) {
+						/** @type {undefined | number} */
 						let last;
 						if (typeof item === "function") {
 							lengths.push(0);
@@ -490,8 +491,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 				}
 				case "boolean": {
 					let lastByte = thing === true ? 1 : 0;
+					/** @type {number[]} */
 					const bytes = [];
 					let count = 1;
+					/** @type {undefined | number} */
 					let n;
 					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
 						const item = data[i + n];
@@ -541,6 +544,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				}
 				case "object": {
 					if (thing === null) {
+						/** @type {number} */
 						let n;
 						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
 							const item = data[i + n];

package/lib/serialization/FileMiddleware.js

@@ -21,7 +21,7 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/fs").IStats} IStats */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
@@ -49,7 +49,7 @@ const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
 
 /**
  * @param {Buffer[]} buffers buffers
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const hashForName = (buffers, hashFunction) => {
@@ -101,7 +101,7 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {(BufferSerializableType | LazyFunction)[]} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction=} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
 const serialize = async (
@@ -336,6 +336,7 @@ const deserialize = async (middleware, name, readFile) => {
 		throw new Error("Invalid file version");
 	}
 	const sectionCount = readUInt32LE();
+	/** @type {number[]} */
 	const lengths = [];
 	let lastLengthPositive = false;
 	for (let i = 0; i < sectionCount; i++) {
@@ -433,11 +434,13 @@ const deserialize = async (middleware, name, readFile) => {
 class FileMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {IntermediateFileSystem} fs filesystem
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {HashFunction} hashFunction hash function to use
 	 */
 	constructor(fs, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
+		/** @type {IntermediateFileSystem} */
 		this.fs = fs;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -454,6 +457,7 @@ class FileMiddleware extends SerializerMiddleware {
 
 				// It's important that we don't touch existing files during serialization
 				// because serialize may read existing files (when deserializing)
+				/** @type {Set<string>} */
 				const allWrittenFiles = new Set();
 				/**
 				 * @param {string | false} name name
@@ -472,6 +476,7 @@ class FileMiddleware extends SerializerMiddleware {
 						 */
 						(resolve, reject) => {
 							let stream = this.fs.createWriteStream(`${file}_`);
+							/** @type {undefined | import("zlib").Gzip | import("zlib").BrotliCompress} */
 							let compression;
 							if (file.endsWith(".gz")) {
 								compression = createGzip({

package/lib/serialization/ObjectMiddleware.js

@@ -18,7 +18,7 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
@@ -111,7 +111,7 @@ const setMapSize = (map, size) => {
 
 /**
  * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const toHash = (buffer, hashFunction) => {
@@ -207,17 +207,21 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
+/** @typedef {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} ExtendContext */
+
 /**
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {ExtendContext} extendContext context extensions
+	 * @param {HashFunction} hashFunction hash function to use
 	 */
 	constructor(extendContext, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
+		/** @type {ExtendContext} */
 		this.extendContext = extendContext;
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -276,11 +280,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {Constructor} object for serialization
+	 * @param {EXPECTED_ANY} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
 		const proto = Object.getPrototypeOf(object);
+		/** @type {null | Constructor} */
 		let c;
 		if (proto === null) {
 			// Object created with Object.create(null)
@@ -295,7 +300,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		}
 		const config = serializers.get(c);
 
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
+		if (!config) {
+			throw new Error(
+				`No serializer registered for ${/** @type {Constructor} */ (c).name}`
+			);
+		}
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
 		return /** @type {SerializerConfigWithSerializer} */ (config);
@@ -345,6 +354,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		const addReferenceable = (item) => {
 			referenceable.set(item, currentPos++);
 		};
+		/** @type {Map<number, Buffer | [Buffer, Buffer] | Map<string, Buffer>>} */
 		let bufferDedupeMap = new Map();
 		/**
 		 * @param {Buffer} buf buffer
@@ -366,6 +376,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					return buf;
 				}
 				const hash = toHash(entry, this._hashFunction);
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				newMap.set(hash, entry);
 				bufferDedupeMap.set(len, newMap);
@@ -384,8 +395,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					entry.push(buf);
 					return buf;
 				}
+				/** @type {Map<string, Buffer>} */
 				const newMap = new Map();
 				const hash = toHash(buf, this._hashFunction);
+				/** @type {undefined | Buffer} */
 				let found;
 				for (const item of entry) {
 					const itemHash = toHash(item, this._hashFunction);
@@ -408,7 +421,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
+		/** @type {Map<ComplexSerializableType, number>} */
 		let objectTypeLookup = new Map();
+		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
 		/**
 		 * @param {ComplexSerializableType} item item to stack
@@ -441,12 +456,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 							if (item.constructor === Object) {
 								return `Object { ${Object.keys(item).join(", ")} }`;
 							}
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
+							if (item.constructor === Map) {
+								return `Map { ${/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */ (item).size} items }`;
+							}
 							if (item.constructor === Array) {
-								return `Array { ${item.length} items }`;
+								return `Array { ${/** @type {EXPECTED_ANY[]} */ (item).length} items }`;
+							}
+							if (item.constructor === Set) {
+								return `Set { ${/** @type {Set<EXPECTED_ANY>} */ (item).size} items }`;
+							}
+							if (item.constructor === RegExp) {
+								return /** @type {RegExp} */ (item).toString();
 							}
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
 							return `${item.constructor.name}`;
 						}
 						return `Object [null prototype] { ${Object.keys(item).join(
@@ -464,7 +485,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				})
 				.join(" -> ");
 		};
-		/** @type {WeakSet<Error>} */
+		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
 		/** @type {ObjectSerializerContext} */
 		let ctx = {
@@ -723,6 +744,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				} else {
 					const request = nextItem;
+					/** @type {undefined | ObjectSerializer} */
 					let serializer;
 
 					if (typeof request === "number") {
@@ -788,6 +810,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						// As this is only for error handling, we omit creating a Map for
 						// faster access to this information, as this would affect performance
 						// in the good case
+						/** @type {undefined | [Constructor | null, SerializerConfig]} */
 						let serializerEntry;
 						for (const entry of serializers) {
 							if (entry[1].serializer === serializer) {

package/lib/serialization/PlainObjectSerializer.js

@@ -20,7 +20,9 @@ const cache = new WeakMap();
  */
 class ObjectStructure {
 	constructor() {
+		/** @type {undefined | keyof T[]} */
 		this.keys = undefined;
+		/** @type {undefined | Map<keyof T, ObjectStructure<T>>} */
 		this.children = undefined;
 	}
 

package/lib/sharing/ConsumeSharedModule.js

@@ -17,6 +17,9 @@ const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 
+/** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
+const fallbackModuleCache = new WeakMap();
+
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
@@ -27,7 +30,10 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -153,6 +159,57 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Module | null} fallback module
+	 */
+	_getFallbackModule(moduleGraph) {
+		let moduleCache = fallbackModuleCache.get(moduleGraph);
+		if (!moduleCache) {
+			moduleCache = new WeakMap();
+			fallbackModuleCache.set(moduleGraph, moduleCache);
+		}
+		const cached = moduleCache.get(this);
+		if (cached !== undefined) {
+			return cached;
+		}
+
+		/** @type {undefined | null | Module} */
+		let fallbackModule = null;
+
+		if (this.options.import) {
+			if (this.options.eager) {
+				const dep = this.dependencies[0];
+				if (dep) {
+					fallbackModule = moduleGraph.getModule(dep);
+				}
+			} else {
+				const block = this.blocks[0];
+				if (block && block.dependencies.length > 0) {
+					fallbackModule = moduleGraph.getModule(block.dependencies[0]);
+				}
+			}
+		}
+
+		moduleCache.set(this, fallbackModule);
+		return fallbackModule;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean | undefined} strict the importing module is strict
+	 * @returns {ExportsType} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		const fallbackModule = this._getFallbackModule(moduleGraph);
+		if (!fallbackModule) return "dynamic";
+		return fallbackModule.getExportsType(moduleGraph, strict);
+	}
+
 	/**
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
@@ -186,6 +243,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
+		/** @type {undefined | string} */
 		let fallbackCode;
 		if (request) {
 			if (eager) {
@@ -219,6 +277,7 @@ class ConsumeSharedModule extends Module {
 			args.push(fallbackCode);
 		}
 
+		/** @type {string} */
 		let fn;
 
 		if (requiredVersion) {
@@ -232,6 +291,7 @@ class ConsumeSharedModule extends Module {
 		}
 
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));
 		return {