webpack 5.97.1 → 5.104.1

package/lib/library/AbstractLibraryPlugin.js

@@ -17,8 +17,10 @@ const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin")
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 const COMMON_LIBRARY_NAME_MESSAGE =
@@ -32,14 +34,18 @@ const COMMON_LIBRARY_NAME_MESSAGE =
  * @property {T} options
  */
 
+/**
+ * @typedef {object} AbstractLibraryPluginOptions
+ * @property {string} pluginName name of the plugin
+ * @property {LibraryType} type used library type
+ */
+
 /**
  * @template T
  */
 class AbstractLibraryPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {string} options.pluginName name of the plugin
-	 * @param {LibraryType} options.type used library type
+	 * @param {AbstractLibraryPluginOptions} options options
 	 */
 	constructor({ pluginName, type }) {
 		this._pluginName = pluginName;
@@ -54,7 +60,7 @@ class AbstractLibraryPlugin {
 	 */
 	apply(compiler) {
 		const { _pluginName } = this;
-		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
+		compiler.hooks.thisCompilation.tap(_pluginName, (compilation) => {
 			compilation.hooks.finishModules.tap(
 				{ name: _pluginName, stage: 10 },
 				() => {
@@ -89,11 +95,12 @@ class AbstractLibraryPlugin {
 
 			/**
 			 * @param {Chunk} chunk chunk
-			 * @returns {TODO} options for the chunk
+			 * @returns {T | false} options for the chunk
 			 */
-			const getOptionsForChunk = chunk => {
-				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
+			const getOptionsForChunk = (chunk) => {
+				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0) {
 					return false;
+				}
 				const options = chunk.getEntryOptions();
 				const library = options && options.library;
 				return this._parseOptionsCached(
@@ -157,7 +164,7 @@ class AbstractLibraryPlugin {
 				this.strictRuntimeBailout !==
 				AbstractLibraryPlugin.prototype.strictRuntimeBailout
 			) {
-				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
+				hooks.strictRuntimeBailout.tap(_pluginName, (renderContext) => {
 					const options = getOptionsForChunk(renderContext.chunk);
 					if (options === false) return;
 					return this.strictRuntimeBailout(renderContext, {
@@ -168,6 +175,20 @@ class AbstractLibraryPlugin {
 				});
 			}
 
+			if (
+				this.renderModuleContent !==
+				AbstractLibraryPlugin.prototype.renderModuleContent
+			) {
+				hooks.renderModuleContent.tap(
+					_pluginName,
+					(source, module, renderContext) =>
+						this.renderModuleContent(source, module, renderContext, {
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						})
+				);
+			}
+
 			if (
 				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
 			) {
@@ -219,6 +240,7 @@ class AbstractLibraryPlugin {
 	 */
 	parseOptions(library) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -251,13 +273,14 @@ class AbstractLibraryPlugin {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
+	 * @param {RuntimeRequirements} set runtime requirements
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
 	runtimeRequirements(chunk, set, libraryContext) {
-		if (this.render !== AbstractLibraryPlugin.prototype.render)
+		if (this.render !== AbstractLibraryPlugin.prototype.render) {
 			set.add(RuntimeGlobals.returnExportsFromRuntime);
+		}
 	}
 
 	/**
@@ -281,6 +304,17 @@ class AbstractLibraryPlugin {
 		return source;
 	}
 
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleRenderContext} renderContext render context
+	 * @param {Omit<LibraryContext<T>, "options">} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderModuleContent(source, module, renderContext, libraryContext) {
+		return source;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash
@@ -298,4 +332,5 @@ class AbstractLibraryPlugin {
 }
 
 AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
+
 module.exports = AbstractLibraryPlugin;

package/lib/library/AmdLibraryPlugin.js

@@ -15,10 +15,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} AmdLibraryPluginOptions
@@ -85,13 +87,13 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
 			.filter(
-				m =>
+				(m) =>
 					m instanceof ExternalModule &&
 					(m.externalType === "amd" || m.externalType === "amd-require")
 			);
 		const externals = /** @type {ExternalModule[]} */ (modules);
 		const externalsDepsArray = JSON.stringify(
-			externals.map(m =>
+			externals.map((m) =>
 				typeof m.request === "object" && !Array.isArray(m.request)
 					? m.request.amd
 					: m.request
@@ -99,7 +101,7 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		);
 		const externalsArguments = externals
 			.map(
-				m =>
+				(m) =>
 					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
 						`${chunkGraph.getModuleId(m)}`
 					)}__`

package/lib/library/AssignLibraryPlugin.js

@@ -16,15 +16,21 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryExport} LibraryExport */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 const KEYWORD_REGEX =
 	/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
@@ -36,7 +42,7 @@ const IDENTIFIER_REGEX =
  * @param {string} name name to be validated
  * @returns {boolean} true, when valid
  */
-const isNameValid = name =>
+const isNameValid = (name) =>
 	!KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
 
 /**
@@ -83,25 +89,30 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 	}
 
 	// print the last property as property access if not yet printed
-	if (i < accessor.length)
+	if (i < accessor.length) {
 		current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
+	}
 
 	return current;
 };
 
+/** @typedef {string[] | "global"} LibraryPrefix */
+
 /**
  * @typedef {object} AssignLibraryPluginOptions
  * @property {LibraryType} type
- * @property {string[] | "global"} prefix name prefix
+ * @property {LibraryPrefix} prefix name prefix
  * @property {string | false} declare declare name as variable
- * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
- * @property {"copy"|"assign"=} named behavior for named library name
+ * @property {"error" | "static" | "copy" | "assign"} unnamed behavior for unnamed library name
+ * @property {"copy" | "assign"=} named behavior for named library name
  */
 
+/** @typedef {string | string[]} LibraryName */
+
 /**
  * @typedef {object} AssignLibraryPluginParsed
- * @property {string | string[]} name
- * @property {string | string[] | undefined} export
+ * @property {LibraryName} name
+ * @property {LibraryExport=} export
  */
 
 /**
@@ -140,7 +151,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 			);
 		}
-		const _name = /** @type {string | string[]} */ (name);
+		const _name = /** @type {LibraryName} */ (name);
 		return {
 			name: _name,
 			export: library.export
@@ -175,7 +186,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 
 	/**
 	 * @param {Compilation} compilation the compilation
-	 * @returns {string[]} the prefix
+	 * @returns {LibraryPrefix} the prefix
 	 */
 	_getPrefix(compilation) {
 		return this.prefix === "global"
@@ -187,12 +198,17 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {AssignLibraryPluginParsed} options the library options
 	 * @param {Chunk} chunk the chunk
 	 * @param {Compilation} compilation the compilation
-	 * @returns {Array<string>} the resolved full name
+	 * @returns {string[]} the resolved full name
 	 */
 	_getResolvedFullName(options, chunk, compilation) {
 		const prefix = this._getPrefix(compilation);
-		const fullName = options.name ? prefix.concat(options.name) : prefix;
-		return fullName.map(n =>
+		const fullName = options.name
+			? [
+					...prefix,
+					...(Array.isArray(options.name) ? options.name : [options.name])
+				]
+			: /** @type {string[]} */ (prefix);
+		return fullName.map((n) =>
 			compilation.getPath(n, {
 				chunk
 			})
@@ -242,16 +258,18 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		const topLevelDeclarations =
 			(data && data.get("topLevelDeclarations")) ||
 			(module.buildInfo && module.buildInfo.topLevelDeclarations);
-		if (!topLevelDeclarations)
+		if (!topLevelDeclarations) {
 			return "it doesn't tell about top level declarations.";
+		}
 		const fullNameResolved = this._getResolvedFullName(
 			options,
 			chunk,
 			compilation
 		);
 		const base = fullNameResolved[0];
-		if (topLevelDeclarations.has(base))
+		if (topLevelDeclarations.has(base)) {
 			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+		}
 	}
 
 	/**
@@ -303,13 +321,48 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				this._getPrefix(compilation).length,
 				true
 			);
+
+			/** @type {ExportInfoName[]} */
+			const provided = [];
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (!exportInfo.provided) continue;
 				const nameAccess = propertyAccess([exportInfo.name]);
 				result.add(
 					`${exportTarget}${nameAccess} = ${RuntimeGlobals.exports}${exportAccess}${nameAccess};\n`
 				);
+				provided.push(exportInfo.name);
+			}
+
+			const webpackExportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			/** @type {string} */
+			let exports = RuntimeGlobals.exports;
+			if (exportAccess) {
+				result.add(
+					`var __webpack_exports_export__ = ${RuntimeGlobals.exports}${exportAccess};\n`
+				);
+
+				exports = "__webpack_exports_export__";
+			}
+			result.add(`for(var __webpack_i__ in ${exports}) {\n`);
+			const hasProvided = provided.length > 0;
+			if (hasProvided) {
+				result.add(
+					`  if (${JSON.stringify(provided)}.indexOf(__webpack_i__) === -1) {\n`
+				);
 			}
+			result.add(
+				`  ${
+					hasProvided ? "  " : ""
+				}${webpackExportTarget}[__webpack_i__] = ${exports}[__webpack_i__];\n`
+			);
+			if (hasProvided) {
+				result.add("  }\n");
+			}
+			result.add("}\n");
 			result.add(
 				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
 			);
@@ -327,6 +380,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				result.add(
 					`var __webpack_exports_export__ = ${RuntimeGlobals.exports}${exportAccess};\n`
 				);
+
 				exports = "__webpack_exports_export__";
 			}
 			result.add(
@@ -349,7 +403,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
+	 * @param {RuntimeRequirements} set runtime requirements
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */

package/lib/library/EnableLibraryPlugin.js

@@ -5,18 +5,24 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
 
-/** @type {WeakMap<Compiler, Set<LibraryType>>} */
+/** @typedef {Set<LibraryType>} LibraryTypes */
+
+/** @type {WeakMap<Compiler, LibraryTypes>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @typedef {object} EnableLibraryPluginOptions
+ * @property {() => void=} additionalApply function that runs when applying the current plugin.
+ */
+
 /**
  * @param {Compiler} compiler the compiler instance
- * @returns {Set<LibraryType>} enabled types
+ * @returns {LibraryTypes} enabled types
  */
-const getEnabledTypes = compiler => {
+const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {
 		set = new Set();
@@ -28,9 +34,13 @@ const getEnabledTypes = compiler => {
 class EnableLibraryPlugin {
 	/**
 	 * @param {LibraryType} type library type that should be available
+	 * @param {EnableLibraryPluginOptions} options options of EnableLibraryPlugin
 	 */
-	constructor(type) {
+	constructor(type, options = {}) {
+		/** @type {LibraryType} */
 		this.type = type;
+		/** @type {EnableLibraryPluginOptions} */
+		this.options = options;
 	}
 
 	/**
@@ -54,9 +64,7 @@ class EnableLibraryPlugin {
 					"EnableLibraryPlugin need to be used to enable this type of library. " +
 					'This usually happens through the "output.enabledLibraryTypes" option. ' +
 					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
-					`These types are enabled: ${Array.from(
-						getEnabledTypes(compiler)
-					).join(", ")}`
+					`These types are enabled: ${[...getEnabledTypes(compiler)].join(", ")}`
 			);
 		}
 	}
@@ -67,26 +75,30 @@ class EnableLibraryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { type } = this;
+		const { type, options } = this;
 
 		// Only enable once
 		const enabled = getEnabledTypes(compiler);
 		if (enabled.has(type)) return;
 		enabled.add(type);
 
+		if (typeof options.additionalApply === "function") {
+			options.additionalApply();
+		}
+
 		if (typeof type === "string") {
 			const enableExportProperty = () => {
-				const ExportPropertyTemplatePlugin = require("./ExportPropertyLibraryPlugin");
-				new ExportPropertyTemplatePlugin({
-					type,
-					nsObjectUsed: !["module", "modern-module"].includes(type),
-					runtimeExportsUsed: type !== "modern-module"
+				const ExportPropertyLibraryPlugin = require("./ExportPropertyLibraryPlugin");
+
+				new ExportPropertyLibraryPlugin({
+					type
 				}).apply(compiler);
 			};
 			switch (type) {
 				case "var": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: [],
@@ -98,6 +110,7 @@ class EnableLibraryPlugin {
 				case "assign-properties": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: [],
@@ -110,6 +123,7 @@ class EnableLibraryPlugin {
 				case "assign": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: [],
@@ -121,6 +135,7 @@ class EnableLibraryPlugin {
 				case "this": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["this"],
@@ -132,6 +147,7 @@ class EnableLibraryPlugin {
 				case "window": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["window"],
@@ -143,6 +159,7 @@ class EnableLibraryPlugin {
 				case "self": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["self"],
@@ -154,6 +171,7 @@ class EnableLibraryPlugin {
 				case "global": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: "global",
@@ -165,6 +183,7 @@ class EnableLibraryPlugin {
 				case "commonjs": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["exports"],
@@ -176,6 +195,7 @@ class EnableLibraryPlugin {
 				case "commonjs-static": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["exports"],
@@ -188,6 +208,7 @@ class EnableLibraryPlugin {
 				case "commonjs-module": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+
 					new AssignLibraryPlugin({
 						type,
 						prefix: ["module", "exports"],
@@ -199,7 +220,9 @@ class EnableLibraryPlugin {
 				case "amd":
 				case "amd-require": {
 					enableExportProperty();
+
 					const AmdLibraryPlugin = require("./AmdLibraryPlugin");
+
 					new AmdLibraryPlugin({
 						type,
 						requireAsWrapper: type === "amd-require"
@@ -212,11 +235,15 @@ class EnableLibraryPlugin {
 						compiler.options.output.iife = true;
 
 						class WarnFalseIifeUmdPlugin {
+							/**
+							 * @param {Compiler} compiler the compiler instance
+							 */
 							apply(compiler) {
 								compiler.hooks.thisCompilation.tap(
 									"WarnFalseIifeUmdPlugin",
-									compilation => {
+									(compilation) => {
 										const FalseIIFEUmdWarning = require("../FalseIIFEUmdWarning");
+
 										compilation.warnings.push(new FalseIIFEUmdWarning());
 									}
 								);
@@ -226,7 +253,9 @@ class EnableLibraryPlugin {
 						new WarnFalseIifeUmdPlugin().apply(compiler);
 					}
 					enableExportProperty();
+
 					const UmdLibraryPlugin = require("./UmdLibraryPlugin");
+
 					new UmdLibraryPlugin({
 						type,
 						optionalAmdExternalAsGlobal: type === "umd2"
@@ -235,7 +264,9 @@ class EnableLibraryPlugin {
 				}
 				case "system": {
 					enableExportProperty();
+
 					const SystemLibraryPlugin = require("./SystemLibraryPlugin");
+
 					new SystemLibraryPlugin({
 						type
 					}).apply(compiler);
@@ -243,28 +274,23 @@ class EnableLibraryPlugin {
 				}
 				case "jsonp": {
 					enableExportProperty();
+
 					const JsonpLibraryPlugin = require("./JsonpLibraryPlugin");
+
 					new JsonpLibraryPlugin({
 						type
 					}).apply(compiler);
 					break;
 				}
-				case "module": {
-					enableExportProperty();
+				case "module":
+				case "modern-module": {
 					const ModuleLibraryPlugin = require("./ModuleLibraryPlugin");
+
 					new ModuleLibraryPlugin({
 						type
 					}).apply(compiler);
 					break;
 				}
-				case "modern-module": {
-					enableExportProperty();
-					const ModernModuleLibraryPlugin = require("./ModernModuleLibraryPlugin");
-					new ModernModuleLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
 				default:
 					throw new Error(`Unsupported library type ${type}.
 Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -15,22 +15,24 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryExport} LibraryExport */
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} ExportPropertyLibraryPluginParsed
- * @property {string | string[]} export
+ * @property {LibraryExport=} export
  */
 
 /**
  * @typedef {object} ExportPropertyLibraryPluginOptions
  * @property {LibraryType} type
- * @property {boolean} nsObjectUsed the namespace object is used
- * @property {boolean} runtimeExportsUsed runtime exports are used
  */
 /**
  * @typedef {ExportPropertyLibraryPluginParsed} T
@@ -40,13 +42,11 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	/**
 	 * @param {ExportPropertyLibraryPluginOptions} options options
 	 */
-	constructor({ type, nsObjectUsed, runtimeExportsUsed }) {
+	constructor({ type }) {
 		super({
 			pluginName: "ExportPropertyLibraryPlugin",
 			type
 		});
-		this.nsObjectUsed = nsObjectUsed;
-		this.runtimeExportsUsed = runtimeExportsUsed;
 	}
 
 	/**
@@ -55,7 +55,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	 */
 	parseOptions(library) {
 		return {
-			export: /** @type {string | string[]} */ (library.export)
+			export: library.export
 		};
 	}
 
@@ -80,25 +80,19 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 			exportsInfo.canMangleUse = false;
 		} else {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
-			if (this.nsObjectUsed) {
-				exportsInfo.setUsedInUnknownWay(runtime);
-			} else {
-				exportsInfo.setAllKnownExportsUsed(runtime);
-			}
+			exportsInfo.setUsedInUnknownWay(runtime);
 		}
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
+	 * @param {RuntimeRequirements} set runtime requirements
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
 	runtimeRequirements(chunk, set, libraryContext) {
-		if (this.runtimeExportsUsed) {
-			set.add(RuntimeGlobals.exports);
-		}
+		set.add(RuntimeGlobals.exports);
 	}
 
 	/**