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

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -8,9 +8,10 @@
 const Dependency = require("../Dependency");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const NullDependency = require("./NullDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
@@ -28,11 +29,6 @@ const NullDependency = require("./NullDependency");
  * } from "../javascript/JavascriptModule"
  */
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
-);
-
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
 	 * Creates an instance of HarmonyExportSpecifierDependency.
@@ -147,14 +143,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	apply(
 		dependency,
 		source,
-		{
-			module,
-			moduleGraph,
-			initFragments,
-			runtime,
-			runtimeTemplate,
-			concatenationScope
-		}
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
 	) {
 		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
 		// a wrapped module's bindings stay inside the wrapper, not in the shared scope
@@ -180,54 +169,32 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
-		const canUseValueBinding =
+		const valueFormat =
 			dep.constValue !== undefined &&
 			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 				.isCircular === false;
 
-		// A library exporting the same bindings natively reads none of them back off the
-		// exports object, so it takes the call over and emits it only where wrapped.
-		const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-			runtimeTemplate.compilation
+		const meta = moduleGraph.getMetaIfExisting(module);
+
+		const onDemand =
+			!concatenationScope &&
+			meta !== undefined &&
+			meta.onDemandExports === true;
+
+		/** @type {ExportMap} */
+		const map = new Map();
+		map.set(used, {
+			value: `/* binding */ ${dep.id}`,
+			type: valueFormat ? ExportBindingType.Value : ExportBindingType.Getter
+		});
+		initFragments.push(
+			new HarmonyExportInitFragment(
+				module.exportsArgument,
+				map,
+				undefined,
+				onDemand
+			)
 		);
-		const onDemand = hooks.onDemandExportsGeneration.isUsed()
-			? (/** @type {string} */ definition, /** @type {boolean} */ placeAtEnd) =>
-					hooks.onDemandExportsGeneration.call(
-						module,
-						runtime,
-						definition,
-						placeAtEnd
-					) === true
-			: undefined;
-
-		if (canUseValueBinding) {
-			initFragments.push(
-				new ExportBindingInitFragment(
-					module.exportsArgument,
-					[
-						{
-							name: used,
-							value: `/* binding */ ${dep.id}`,
-							bindingType: "value"
-						}
-					],
-					true,
-					onDemand
-				)
-			);
-		} else {
-			/** @type {ExportMap} */
-			const map = new Map();
-			map.set(used, `/* binding */ ${dep.id}`);
-			initFragments.push(
-				new HarmonyExportInitFragment(
-					module.exportsArgument,
-					map,
-					undefined,
-					onDemand
-				)
-			);
-		}
 	}
 };
 

package/lib/dependencies/HarmonyImportBareSideEffectDependency.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { ASSET_TYPE } = require("../ModuleSourceTypeConstants");
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn } from "../Dependency" */
+
+/**
+ * Whether a module is emitted as a file of its own, asked of the module so a
+ * plugin emitting the same way is treated alike. `buildInfo.filename` cannot
+ * serve here: generation sets it long after a connection has to know whether
+ * it is active.
+ * @param {Module} module the module to look up
+ * @returns {boolean} true when it emits a file
+ */
+const emitsOwnFile = (module) => module.getSourceTypes().has(ASSET_TYPE);
+
+/**
+ * An `import "..."` that declares no binding. It is a separate class rather
+ * than a flag so it costs nothing per instance, and the bound form — much the
+ * more common one — keeps the base class and its inline caches untouched.
+ */
+class HarmonyImportBareSideEffectDependency extends HarmonyImportSideEffectDependency {
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection) => {
+			const refModule = connection.resolvedModule;
+
+			if (!refModule) return true;
+			// Nothing reads the module, so emitting its file is the only thing the
+			// import can have been written for.
+			if (emitsOwnFile(refModule)) return true;
+
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
+	}
+}
+
+makeSerializable(
+	HarmonyImportBareSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportBareSideEffectDependency"
+);
+
+HarmonyImportBareSideEffectDependency.Template =
+	HarmonyImportSideEffectDependency.Template;
+
+module.exports = HarmonyImportBareSideEffectDependency;

package/lib/dependencies/HarmonyImportDependency.js

@@ -11,11 +11,14 @@ const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const memoize = require("../util/memoize");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
+const getExternalModule = memoize(() => require("../ExternalModule"));
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
@@ -97,6 +100,36 @@ const getNonOptionalPart = (members, membersOptionals) => {
 
 /** @typedef {string[]} Ids */
 
+/**
+ * Export names a lazy barrel still defers, so they are missing from its provided
+ * exports without being absent from the module.
+ * @param {Module} module the imported module
+ * @returns {Set<string> | true | undefined} deferred names, true when a deferred star re-export may provide any name, undefined when none
+ */
+const getDeferredExports = (module) => {
+	const factoryMeta = module.factoryMeta;
+	if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+	/** @type {Set<string> | undefined} */
+	let names;
+	for (const dep of module.dependencies) {
+		// TODO remove in webpack 6
+		// These may be missing on custom dependency types not extending the base Dependency
+		if (
+			typeof dep.getLazyUntil !== "function" ||
+			typeof dep.isLazy !== "function"
+		) {
+			continue;
+		}
+		if (!dep.isLazy()) continue;
+		const until = dep.getLazyUntil();
+		if (until === Dependency.LAZY_UNTIL_FALLBACK) return true;
+		if (until !== Dependency.LAZY_UNTIL_ID) continue;
+		if (names === undefined) names = new Set();
+		names.add(/** @type {string} */ (dep.getLazyName()));
+	}
+	return names;
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HarmonyImportDependency.
@@ -185,9 +218,14 @@ class HarmonyImportDependency extends ModuleDependency {
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(this));
 		const meta = moduleGraph.getMeta(module);
 
+		// An async external is a promise webpack awaits, not a module record with
+		// an evaluating state, so deferring its namespace would never throw.
 		const isDeferred =
 			ImportPhaseUtils.isDefer(this.phase) &&
-			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
+			!(
+				/** @type {BuildMeta} */ (importedModule.buildMeta).async &&
+				importedModule instanceof getExternalModule()
+			);
 
 		const metaKey = isDeferred ? "deferredImportVarMap" : "importVarMap";
 		let importVarMap = meta[metaKey];
@@ -283,48 +321,63 @@ class HarmonyImportDependency extends ModuleDependency {
 				(exportsType !== "default-with-named" || ids[0] !== "default") &&
 				moduleGraph.isExportProvided(importedModule, ids) === false
 			) {
-				// We are sure that it's not provided
-
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-								? " (module has no exports)"
-								: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map((id) => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
+				const deferredExports = getDeferredExports(importedModule);
+
+				if (
+					deferredExports !== true &&
+					(deferredExports === undefined || !deferredExports.has(ids[0]))
+				) {
+					// We are sure that it's not provided
+
+					// Try to provide detailed info in the error message
+					let pos = 0;
+					let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					while (pos < ids.length && exportsInfo) {
+						const id = ids[pos++];
+						const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+						if (exportInfo.provided === false) {
+							// We are sure that it's not provided
+							let providedExports = exportsInfo.getProvidedExports();
+							// only the first level names the imported module itself
+							if (
+								pos === 1 &&
+								deferredExports !== undefined &&
+								Array.isArray(providedExports)
+							) {
+								providedExports = [...providedExports, ...deferredExports];
+							}
+							const moreInfo = !Array.isArray(providedExports)
+								? " (possible exports unknown)"
+								: providedExports.length === 0
+									? " (module has no exports)"
+									: ` (possible exports: ${providedExports.join(", ")})`;
+							return [
+								new HarmonyLinkingError(
+									`export ${ids
+										.slice(0, pos)
+										.map((id) => `'${id}'`)
+										.join(".")} ${additionalMessage} was not found in '${
+										this.userRequest
+									}'${moreInfo}`
+								)
+							];
+						}
+						exportsInfo =
+							/** @type {ExportsInfo} */
+							(exportInfo.getNestedExportsInfo());
 					}
-					exportsInfo =
-						/** @type {ExportsInfo} */
-						(exportInfo.getNestedExportsInfo());
-				}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map((id) => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
+					// General error message
+					return [
+						new HarmonyLinkingError(
+							`export ${ids
+								.map((id) => `'${id}'`)
+								.join(".")} ${additionalMessage} was not found in '${
+								this.userRequest
+							}'`
+						)
+					];
+				}
 			}
 		}
 		switch (exportsType) {
@@ -468,8 +521,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
+		// A module deferring itself is already evaluating: awaiting it would probe
+		// the deferred namespace and force the evaluation it must not trigger.
+		const isSelfDeferred =
+			ImportPhaseUtils.isDefer(dep.phase) && referencedModule === module;
 		if (
 			referencedModule &&
+			!isSelfDeferred &&
 			templateContext.moduleGraph.isAsync(referencedModule)
 		) {
 			templateContext.initFragments.push(