@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/json/JsonGenerator.js

@@ -259,7 +259,13 @@ class JsonGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(Generator.throwBuildErrorCode(error));
+		return new RawSource(
+			Generator.throwBuildErrorCode(
+				error,
+				undefined,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 
 	/**

package/lib/library/ModuleLibraryPlugin.js

@@ -14,15 +14,17 @@ const Template = require("../Template");
 const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
+const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const { InlinedUsedName } = require("../optimize/InlineExports");
+const { toJsStringLiteral } = require("../util/identifier");
 const {
 	RESERVED_IDENTIFIER,
 	SAFE_IDENTIFIER,
 	propertyAccess
 } = require("../util/property");
-const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
+const { getEntryRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @import { Source } from "webpack-sources" */
@@ -37,13 +39,14 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
 /** @import ModuleGraph from "../ModuleGraph" */
-/** @import Module, { BuildMeta } from "../Module" */
+/** @import Module from "../Module" */
 /**
  * @import {
  * 	StartupRenderContext,
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -122,6 +125,18 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
+/**
+ * Renders the import attributes of a reexport in the syntax the author wrote,
+ * since a legacy `assert` clause and a `with` clause are not interchangeable.
+ * @param {ImportAttributes | undefined} attributes the import attributes
+ * @returns {string} the attributes clause, empty when there are none
+ */
+const toAttributesClause = (attributes) => {
+	if (!attributes) return "";
+	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
+	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
+};
+
 /**
  * Whether the export name can also be used as the declared binding name.
  * @param {string} name export name
@@ -156,73 +171,33 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		super.apply(compiler);
 
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
-			const { onDemandExportsGeneration } =
-				ConcatenatedModule.getCompilationHooks(compilation);
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
-			onDemandExportsGeneration.tap(
-				PLUGIN_NAME,
-				(module, runtimes, source, finalName) => {
-					/** @type {BuildMeta} */
-					const buildMeta = module.buildMeta || (module.buildMeta = {});
-
-					/** @type {BuildMeta["exportsSourceByRuntime"]} */
-					const exportsSourceByRuntime =
-						buildMeta.exportsSourceByRuntime ||
-						(buildMeta.exportsSourceByRuntime = new Map());
-
-					/** @type {BuildMeta["exportsFinalNameByRuntime"]} */
-					const exportsFinalNameByRuntime =
-						buildMeta.exportsFinalNameByRuntime ||
-						(buildMeta.exportsFinalNameByRuntime = new Map());
-
-					for (const runtime of runtimes) {
-						const key = getRuntimeKey(runtime);
-						exportsSourceByRuntime.set(key, source);
-						exportsFinalNameByRuntime.set(key, finalName);
-					}
 
-					return true;
-				}
-			);
-			// The same for a plain entry, whose definitions come from a dependency template.
-			// Placed after the module body, which its value bindings read.
-			javascriptHooks.onDemandExportsGeneration.tap(
-				PLUGIN_NAME,
-				(module, runtime, source, placeAtEnd) => {
-					const entries = libraryEntryModules.get(compilation);
-					if (!entries || !entries.has(module)) return;
-					if (!definesOnlyNativeExports(module, compilation.moduleGraph)) {
-						return;
-					}
-					/** @type {BuildMeta} */
-					const buildMeta = module.buildMeta || (module.buildMeta = {});
-					const key = getRuntimeKey(runtime);
-					if (placeAtEnd) {
-						const bindings =
-							buildMeta.exportsBindingSourceByRuntime ||
-							(buildMeta.exportsBindingSourceByRuntime = new Map());
-						bindings.set(key, source);
-					} else {
-						const sources =
-							buildMeta.exportsSourceByRuntime ||
-							(buildMeta.exportsSourceByRuntime = new Map());
-						// The `__esModule` marker and the definitions both land here, so
-						// keep whichever arrived first rather than replacing it.
-						const before = sources.get(key);
-						sources.set(key, before ? `${before}${source}` : source);
+			compilation.hooks.beforeCodeGeneration.tap(PLUGIN_NAME, () => {
+				const entries = libraryEntryModules.get(compilation);
+				if (entries === undefined) return;
+				const { moduleGraph } = compilation;
+				for (const { dependencies } of compilation.entries.values()) {
+					for (const dep of dependencies) {
+						const module = dep && moduleGraph.getModule(dep);
+						if (!module) continue;
+						const root =
+							module instanceof ConcatenatedModule ? module.rootModule : module;
+						if (!entries.has(root)) continue;
+						if (
+							root === module &&
+							!definesOnlyNativeExports(module, moduleGraph)
+						) {
+							continue;
+						}
+						moduleGraph.getMeta(module).onDemandExports = true;
 					}
-					return true;
 				}
-			);
+			});
 
-			// `ModuleLibraryPlugin` stashes the on-demand exports source via
-			// `onDemandExportsGeneration` and only re-emits it when the
-			// module is wrapped in an IIFE/factory. When the entry is
-			// inlined directly, the stashed source — and the
-			// `definePropertyGetters` / `requireScope` runtime helpers it
-			// pulled in — never make it into the output. Drop those helpers
-			// from the chunk's set so the bundle stays clean.
+			// The stashed exports source is re-emitted only where the entry is wrapped;
+			// inlined directly, the helpers it pulled in have no reader and can go.
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
@@ -240,22 +215,16 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
 
 					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
-					const runtimeKey = getRuntimeKey(chunk.runtime);
-					const buildMeta = module.buildMeta;
-					const takenOver =
-						(buildMeta &&
-							buildMeta.exportsSourceByRuntime &&
-							buildMeta.exportsSourceByRuntime.has(runtimeKey)) ||
-						(buildMeta &&
-							buildMeta.exportsBindingSourceByRuntime &&
-							buildMeta.exportsBindingSourceByRuntime.has(runtimeKey));
-					if (!takenOver) return;
 					const codeGenResult = codeGenerationResults.get(
 						module,
 						chunk.runtime
 					);
-					const jsSource =
-						codeGenResult && codeGenResult.sources.get("javascript");
+					const { data } = codeGenResult;
+					const takenOver =
+						data !== undefined &&
+						(data.has("exportsSource") || data.has("exportsBindingSource"));
+					if (!takenOver) return;
+					const jsSource = codeGenResult.sources.get("javascript");
 					if (
 						jsSource &&
 						String(jsSource.source()).includes(`${RuntimeGlobals.require}.`)
@@ -367,6 +336,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 		}
+		this._checkStarReexportedExternals(module, compilation);
 		moduleGraph.addExtraReason(module, "used as library export");
 		let entries = libraryEntryModules.get(compilation);
 		if (entries === undefined) {
@@ -376,6 +346,61 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		entries.add(module);
 	}
 
+	/**
+	 * Reports every external the entry star-reexports whose request names a property
+	 * path, which `export *` has no way to reference.
+	 * @param {Module} module the library entry module
+	 * @param {Compilation} compilation the compilation
+	 * @returns {void}
+	 */
+	_checkStarReexportedExternals(module, compilation) {
+		const { moduleGraph } = compilation;
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set([module]);
+		/** @type {Module[]} */
+		const queue = [module];
+		/** @type {Set<ExternalModule>} */
+		const unsupportedExternals = new Set();
+
+		for (const current of queue) {
+			for (const connection of moduleGraph.getOutgoingConnections(current)) {
+				const dep = connection.dependency;
+
+				// Only handle star-reexport statement
+				if (
+					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep.name !== null
+				) {
+					continue;
+				}
+				const importedModule = connection.resolvedModule;
+
+				// Only a module providing unknown exports keeps its reexport rendered
+				if (
+					moduleGraph.getExportsInfo(importedModule)._otherExportsInfo
+						.provided !== null
+				) {
+					continue;
+				}
+				if (importedModule instanceof ExternalModule) {
+					const request = importedModule.getResolvedRequest();
+					if (Array.isArray(request) && request.length > 1) {
+						unsupportedExternals.add(importedModule);
+					}
+				} else if (!visitedReexportModules.has(importedModule)) {
+					visitedReexportModules.add(importedModule);
+					queue.push(importedModule);
+				}
+			}
+		}
+
+		for (const externalModule of unsupportedExternals) {
+			compilation.errors.push(
+				new ExternalStarReexportError(externalModule, module)
+			);
+		}
+	}
+
 	/**
 	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
@@ -415,14 +440,17 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	) {
 		const result = new ConcatSource(source);
 		/** @type {Set<string>} */
-		const moduleRequests = new Set();
+		const externalReexports = new Set();
 		/** @type {Map<string, string | InlinedUsedName>} */
 		const unknownProvidedExports = new Map();
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set();
 
 		/**
 		 * Resolves dynamic star reexport.
 		 * @param {Module} module the module
 		 * @param {boolean} isDynamicReexport if module is dynamic reexported
+		 * @returns {void}
 		 */
 		const resolveDynamicStarReexport = (module, isDynamicReexport) => {
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
@@ -445,8 +473,22 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					) {
 						// Handle export * from 'external'
 						if (importedModule instanceof ExternalModule) {
-							moduleRequests.add(importedModule.userRequest);
-						} else {
+							const request = importedModule.getResolvedRequest();
+							// A property path is reported by `_checkStarReexportedExternals`,
+							// and an absent one by the external's own build
+							const specifier =
+								typeof request === "string"
+									? request
+									: Array.isArray(request) && request.length === 1
+										? request[0]
+										: undefined;
+							if (specifier !== undefined) {
+								externalReexports.add(
+									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
+								);
+							}
+						} else if (!visitedReexportModules.has(importedModule)) {
+							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
 						}
 					}
@@ -473,8 +515,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 		resolveDynamicStarReexport(module, false);
 
-		for (const request of moduleRequests) {
-			result.add(`export * from "${request}";\n`);
+		for (const reexport of externalReexports) {
+			result.add(reexport);
 		}
 
 		for (const [origin, used] of unknownProvidedExports) {
@@ -520,19 +562,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				]
 			: moduleGraph.getExportsInfo(module).orderedExports;
 
-		const exportsFinalNameByRuntime =
-			(module.buildMeta &&
-				module.buildMeta.exportsFinalNameByRuntime &&
-				module.buildMeta.exportsFinalNameByRuntime.get(
-					getRuntimeKey(chunk.runtime)
-				)) ||
-			{};
+		const { data } = codeGenerationResults.get(module, chunk.runtime);
 
 		const isInlinedEntryWithoutIIFE = inlined && !inlinedInIIFE;
 		// Direct export bindings from on-demand concatenation
-		const definitions = isInlinedEntryWithoutIIFE
-			? exportsFinalNameByRuntime
-			: {};
+		/** @type {Record<string, string>} */
+		const definitions =
+			(isInlinedEntryWithoutIIFE && data && data.get("exportsFinalName")) || {};
 
 		/** @type {string[]} */
 		const shortHandedExports = [];
@@ -566,15 +602,12 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				.treatAsCommonJs;
 		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
 
-		// A single (non-concatenated) inlined entry is rendered at the top
-		// level, so its own declarations are top-level bindings we can export
-		// directly — keeping ESM live bindings instead of snapshotting
-		// `__webpack_exports__.x` into a `const`. Concatenated entries already
-		// get direct bindings via `definitions` above.
+		// A single inlined entry renders at the top level, so its declarations are
+		// bindings that can be exported directly, keeping ESM live bindings rather
+		// than snapshotting them into a `const`.
 		/** @type {Map<string, string> | undefined} */
 		let directBindings;
 		if (isInlinedEntryWithoutIIFE && !treatAsCommonJs) {
-			const { data } = codeGenerationResults.get(module, chunk.runtime);
 			const topLevelDeclarations =
 				(data && data.get("topLevelDeclarations")) ||
 				(module.buildInfo && module.buildInfo.topLevelDeclarations);
@@ -593,15 +626,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 
-		// Taken over by `onDemandExportsGeneration` above, and re-emitted by
-		// `renderModuleContent` only where the module is wrapped — which is not here.
-		const bindingsTakenOver = Boolean(
-			module.buildMeta &&
-			module.buildMeta.exportsBindingSourceByRuntime &&
-			module.buildMeta.exportsBindingSourceByRuntime.has(
-				getRuntimeKey(chunk.runtime)
-			)
-		);
+		const bindingsTakenOver =
+			data !== undefined && data.has("exportsBindingSource");
 
 		const moduleExportsInfo = moduleGraph.getExportsInfo(module);
 
@@ -623,7 +649,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		}
 
 		// Try to find all known exports of the entry module
-		outer: for (const exportInfo of exportInfos) {
+		for (const exportInfo of exportInfos) {
 			if (!exportInfo.provided) continue;
 
 			const originalName = exportInfo.name;
@@ -631,20 +657,40 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			if (skipRenderDefaultExport && originalName === "default") continue;
 
 			// Try to find all exports from the reexported modules
-			const target = exportInfo.findTarget(moduleGraph, (_m) => true);
-			// A namespace object target (`export * as ns from "./module"`) has no
-			// export name, so there is nothing that could be missing
-			if (target && target.export) {
-				const targetExport = target.export[0];
-				const reexportsInfo = moduleGraph.getExportsInfo(target.module);
-				for (const reexportInfo of reexportsInfo.orderedExports) {
-					if (
-						reexportInfo.provided === false &&
-						reexportInfo.name !== "default" &&
-						reexportInfo.name === targetExport
-					) {
-						continue outer;
-					}
+			const target = exportInfo.getTarget(moduleGraph);
+
+			// A re-export is provided even when its target lacks the export, and
+			// the path can end in a property access, so every name is looked up.
+			if (
+				target &&
+				target.export &&
+				target.export[target.export.length - 1] !== "default" &&
+				moduleGraph
+					.getExportsInfo(target.module)
+					.isExportProvided(target.export) === false
+			) {
+				continue;
+			}
+
+			if (
+				target &&
+				target.module instanceof ExternalModule &&
+				target.export &&
+				target.export.length === 1 &&
+				codeGenerationResults.has(target.module, chunk.runtime)
+			) {
+				const reexport = codeGenerationResults.getData(
+					target.module,
+					chunk.runtime,
+					"externalReexport"
+				);
+				if (reexport) {
+					if (!bindingsTakenOver) needExportsDeclaration = true;
+					result.add(
+						`export { ${toExportName(target.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
+					);
+					alreadyRenderedExports.add(originalName);
+					continue;
 				}
 			}
 
@@ -690,7 +736,6 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					finalName.includes("("))
 			) {
 				if (exportInfo.isReexport()) {
-					const { data } = codeGenerationResults.get(module, chunk.runtime);
 					const topLevelDeclarations =
 						(data && data.get("topLevelDeclarations")) ||
 						(module.buildInfo && module.buildInfo.topLevelDeclarations);
@@ -769,19 +814,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	renderModuleContent(
 		source,
 		module,
-		{ factory, inlinedInIIFE, chunk },
+		{ factory, inlinedInIIFE, chunk, codeGenerationResults },
 		libraryContext
 	) {
-		const runtimeKey = getRuntimeKey(chunk.runtime);
-		const buildMeta = module.buildMeta;
-		const exportsSource =
-			buildMeta &&
-			buildMeta.exportsSourceByRuntime &&
-			buildMeta.exportsSourceByRuntime.get(runtimeKey);
-		const bindingSource =
-			buildMeta &&
-			buildMeta.exportsBindingSourceByRuntime &&
-			buildMeta.exportsBindingSourceByRuntime.get(runtimeKey);
+		const { data } = codeGenerationResults.get(module, chunk.runtime);
+		if (data === undefined) return source;
+		const exportsSource = data.get("exportsSource");
+		const bindingSource = data.get("exportsBindingSource");
 
 		// Re-add the exports source in a factory or IIFE-wrapped startup module; value
 		// bindings read the declarations above them, so those go after the body.