Improve synthetic entry handling

src/Bundle.ts

@@ -22,6 +22,7 @@ import { timeEnd, timeStart } from './utils/timers';
 
 export default class Bundle {
 	private facadeChunkByModule = new Map<Module, Chunk>();
+	private includedNamespaces = new Set<Module>();
 
 	constructor(
 		private readonly outputOptions: NormalizedOutputOptions,
@@ -202,6 +203,7 @@ export default class Bundle {
 				this.graph.modulesById,
 				chunkByModule,
 				this.facadeChunkByModule,
+				this.includedNamespaces,
 				alias
 			);
 			chunks.push(chunk);

src/Chunk.ts

@@ -135,6 +135,7 @@ export default class Chunk {
 		modulesById: Map<string, Module | ExternalModule>,
 		chunkByModule: Map<Module, Chunk>,
 		facadeChunkByModule: Map<Module, Chunk>,
+		includedNamespaces: Set<Module>,
 		facadedModule: Module,
 		facadeName: FacadeName
 	): Chunk {
@@ -147,6 +148,7 @@ export default class Chunk {
 			modulesById,
 			chunkByModule,
 			facadeChunkByModule,
+			includedNamespaces,
 			null
 		);
 		chunk.assignFacadeName(facadeName, facadedModule);
@@ -176,6 +178,7 @@ export default class Chunk {
 	exportMode: 'none' | 'named' | 'default' = 'named';
 	facadeModule: Module | null = null;
 	id: string | null = null;
+	namespaceVariableName = '';
 	suggestedVariableName: string;
 	variableName = '';
 
@@ -218,12 +221,16 @@ export default class Chunk {
 		private readonly modulesById: Map<string, Module | ExternalModule>,
 		private readonly chunkByModule: Map<Module, Chunk>,
 		private readonly facadeChunkByModule: Map<Module, Chunk>,
+		private readonly includedNamespaces: Set<Module>,
 		private readonly manualChunkAlias: string | null
 	) {
 		this.execIndex = orderedModules.length > 0 ? orderedModules[0].execIndex : Infinity;
 		const chunkModules = new Set(orderedModules);
 
 		for (const module of orderedModules) {
+			if (module.namespace.included) {
+				includedNamespaces.add(module);
+			}
 			if (this.isEmpty && module.isIncluded()) {
 				this.isEmpty = false;
 			}
@@ -234,8 +241,8 @@ export default class Chunk {
 				if (!chunkModules.has(importer)) {
 					this.dynamicEntryModules.push(module);
 					// Modules with synthetic exports need an artificial namespace for dynamic imports
-					if (module.syntheticNamedExports) {
-						module.namespace.include();
+					if (module.syntheticNamedExports && !outputOptions.preserveModules) {
+						includedNamespaces.add(module);
 						this.exports.add(module.namespace);
 					}
 				}
@@ -359,6 +366,7 @@ export default class Chunk {
 						this.modulesById,
 						this.chunkByModule,
 						this.facadeChunkByModule,
+						this.includedNamespaces,
 						module,
 						facadeName
 					)
@@ -379,7 +387,7 @@ export default class Chunk {
 			) {
 				this.strictFacade = true;
 			} else if (!this.facadeChunkByModule.get(module)?.strictFacade) {
-				module.namespace.include();
+				this.includedNamespaces.add(module);
 				this.exports.add(module.namespace);
 			}
 		}
@@ -581,7 +589,7 @@ export default class Chunk {
 
 		for (const module of this.orderedModules) {
 			let renderedLength = 0;
-			if (module.isIncluded()) {
+			if (module.isIncluded() || this.includedNamespaces.has(module)) {
 				const source = module.render(renderOptions).trim();
 				renderedLength = source.length();
 				if (renderedLength) {
@@ -591,7 +599,7 @@ export default class Chunk {
 					this.usedModules.push(module);
 				}
 				const namespace = module.namespace;
-				if (namespace.included && !this.outputOptions.preserveModules) {
+				if (this.includedNamespaces.has(module) && !this.outputOptions.preserveModules) {
 					const rendered = namespace.renderBlock(renderOptions);
 					if (namespace.renderFirst()) hoistedSource += n + rendered;
 					else magicString.addSource(new MagicString(rendered));
@@ -987,7 +995,7 @@ export default class Chunk {
 	): DependenciesToBeDeconflicted {
 		const dependencies = new Set<Chunk | ExternalModule>();
 		const deconflictedDefault = new Set<ExternalModule>();
-		const deconflictedNamespace = new Set<ExternalModule>();
+		const deconflictedNamespace = new Set<Chunk | ExternalModule>();
 		for (const variable of [...this.exportNamesByVariable.keys(), ...this.imports]) {
 			if (addNonNamespacesAndInteropHelpers || variable.isNamespace) {
 				const module = variable.module!;
@@ -1008,6 +1016,13 @@ export default class Chunk {
 					const chunk = this.chunkByModule.get(module)!;
 					if (chunk !== this) {
 						dependencies.add(chunk);
+						if (
+							addNonNamespacesAndInteropHelpers &&
+							chunk.exportMode === 'default' &&
+							variable.isNamespace
+						) {
+							deconflictedNamespace.add(chunk);
+						}
 					}
 				}
 			}
@@ -1252,7 +1267,8 @@ export default class Chunk {
 			this.chunkByModule,
 			syntheticExports,
 			this.exportNamesByVariable,
-			this.accessedGlobalsByScope
+			this.accessedGlobalsByScope,
+			this.includedNamespaces
 		);
 	}
 
@@ -1261,9 +1277,8 @@ export default class Chunk {
 		// when we are not preserving modules, we need to make all namespace variables available for
 		// rendering the namespace object
 		if (!this.outputOptions.preserveModules) {
-			const namespace = module.namespace;
-			if (namespace.included) {
-				const memberVariables = namespace.getMemberVariables();
+			if (this.includedNamespaces.has(module)) {
+				const memberVariables = module.namespace.getMemberVariables();
 				for (const name of Object.keys(memberVariables)) {
 					moduleImports.add(memberVariables[name]);
 				}
@@ -1288,7 +1303,7 @@ export default class Chunk {
 			}
 		}
 		if (
-			module.namespace.included ||
+			this.includedNamespaces.has(module) ||
 			(module.isEntryPoint && module.preserveSignature !== false) ||
 			module.includedDynamicImporters.some(importer => this.chunkByModule.get(importer) !== this)
 		) {
@@ -1299,9 +1314,9 @@ export default class Chunk {
 				node.included &&
 				resolution instanceof Module &&
 				this.chunkByModule.get(resolution) === this &&
-				!resolution.namespace.included
+				!this.includedNamespaces.has(resolution)
 			) {
-				resolution.namespace.include();
+				this.includedNamespaces.add(resolution);
 				this.ensureReexportsAreAvailableForModule(resolution);
 			}
 		}

src/Graph.ts

@@ -185,7 +185,7 @@ export default class Graph {
 	private includeStatements() {
 		for (const module of [...this.entryModules, ...this.implicitEntryModules]) {
 			if (module.preserveSignature !== false) {
-				module.includeAllExports();
+				module.includeAllExports(false);
 			} else {
 				markModuleAndImpureDependenciesAsExecuted(module);
 			}

src/Module.ts

@@ -96,7 +96,7 @@ export interface AstContext {
 	getModuleName: () => string;
 	getReexports: () => string[];
 	importDescriptions: { [name: string]: ImportDescription };
-	includeAndGetAdditionalMergedNamespaces: () => Variable[];
+	includeAllExports: () => void;
 	includeDynamicImport: (node: ImportExpression) => void;
 	includeVariable: (variable: Variable) => void;
 	magicString: MagicString;
@@ -529,18 +529,20 @@ export default class Module {
 		if (this.ast.shouldBeIncluded(context)) this.ast.include(context, false);
 	}
 
-	includeAllExports() {
+	includeAllExports(includeNamespaceMembers: boolean) {
 		if (!this.isExecuted) {
 			this.graph.needsTreeshakingPass = true;
 			markModuleAndImpureDependenciesAsExecuted(this);
 		}
 
 		for (const exportName of this.getExports()) {
-			const variable = this.getVariableForExportName(exportName);
-			variable.deoptimizePath(UNKNOWN_PATH);
-			if (!variable.included) {
-				variable.include();
-				this.graph.needsTreeshakingPass = true;
+			if (includeNamespaceMembers || exportName !== this.syntheticNamedExports) {
+				const variable = this.getVariableForExportName(exportName);
+				variable.deoptimizePath(UNKNOWN_PATH);
+				if (!variable.included) {
+					variable.include();
+					this.graph.needsTreeshakingPass = true;
+				}
 			}
 		}
 
@@ -555,6 +557,10 @@ export default class Module {
 				variable.module.reexported = true;
 			}
 		}
+
+		if (includeNamespaceMembers) {
+			this.namespace.prepareNamespace(this.includeAndGetAdditionalMergedNamespaces());
+		}
 	}
 
 	includeAllInBundle() {
@@ -679,9 +685,7 @@ export default class Module {
 			getModuleName: this.basename.bind(this),
 			getReexports: this.getReexports.bind(this),
 			importDescriptions: this.importDescriptions,
-			includeAndGetAdditionalMergedNamespaces: this.includeAndGetAdditionalMergedNamespaces.bind(
-				this
-			),
+			includeAllExports: () => this.includeAllExports(true),
 			includeDynamicImport: this.includeDynamicImport.bind(this),
 			includeVariable: this.includeVariable.bind(this),
 			magicString: this.magicString,
@@ -926,7 +930,7 @@ export default class Module {
 		}).resolution;
 		if (resolution instanceof Module) {
 			resolution.includedDynamicImporters.push(this);
-			resolution.includeAllExports();
+			resolution.includeAllExports(true);
 		}
 	}
 

src/ast/variables/NamespaceVariable.ts

@@ -50,26 +50,21 @@ export default class NamespaceVariable extends Variable {
 				memberVariables[name] = this.context.traceExport(name);
 			}
 		}
-		this.memberVariables = memberVariables;
 		return (this.memberVariables = memberVariables);
 	}
 
 	include() {
-		if (!this.included) {
-			this.included = true;
-			for (const identifier of this.references) {
-				if (identifier.context.getModuleExecIndex() <= this.context.getModuleExecIndex()) {
-					this.referencedEarly = true;
-					break;
-				}
-			}
-			this.mergedNamespaces = this.context.includeAndGetAdditionalMergedNamespaces();
-			const memberVariables = this.getMemberVariables();
-			// We directly include the variables instead of context.include to not automatically
-			// generate imports for members from other modules
-			for (const memberName of Object.keys(memberVariables)) memberVariables[memberName].include();
-			if (typeof this.syntheticNamedExports === 'string') {
-				this.context.traceExport(this.syntheticNamedExports).include();
+		this.included = true;
+		this.context.includeAllExports();
+	}
+
+	prepareNamespace(mergedNamespaces: Variable[]) {
+		this.mergedNamespaces = mergedNamespaces;
+		const moduleExecIndex = this.context.getModuleExecIndex();
+		for (const identifier of this.references) {
+			if (identifier.context.getModuleExecIndex() <= moduleExecIndex) {
+				this.referencedEarly = true;
+				break;
 			}
 		}
 	}

src/finalisers/shared/getExportBlock.ts

@@ -164,7 +164,11 @@ function getReexportedImportName(
 		return depNamedExportsMode ? `${moduleVariableName}['default']` : moduleVariableName;
 	}
 	if (imported === '*') {
-		return !isChunk && namespaceInteropHelpersByInteropType[String(interop(moduleId))]
+		return (
+			isChunk
+				? !depNamedExportsMode
+				: namespaceInteropHelpersByInteropType[String(interop(moduleId))]
+		)
 			? namespaceVariableName
 			: moduleVariableName;
 	}

src/finalisers/shared/getInteropBlock.ts

@@ -2,6 +2,7 @@ import { ModuleDeclarationDependency, ReexportSpecifier } from '../../Chunk';
 import { GetInterop } from '../../rollup/types';
 import {
 	defaultInteropHelpersByInteropType,
+	getDefaultOnlyHelper,
 	getHelpersBlock,
 	namespaceInteropHelpersByInteropType
 } from '../../utils/interopHelpers';
@@ -19,46 +20,66 @@ export default function getInteropBlock(
 	t: string
 ): string {
 	const neededInteropHelpers = new Set<string>();
-	const interopStatements = [];
+	const interopStatements: string[] = [];
+	const addInteropStatement = (
+		helperVariableName: string,
+		helper: string,
+		dependencyVariableName: string
+	): void => {
+		neededInteropHelpers.add(helper);
+		interopStatements.push(
+			`${varOrConst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`
+		);
+	};
 	for (const {
 		defaultVariableName,
 		imports,
 		id,
 		isChunk,
 		name,
+		namedExportsMode,
 		namespaceVariableName,
 		reexports
 	} of dependencies) {
-		if (!isChunk) {
+		if (isChunk) {
+			for (const { imported, reexported } of [
+				...(imports || []),
+				...(reexports || [])
+			] as ReexportSpecifier[]) {
+				if (imported === '*' && reexported !== '*') {
+					if (!namedExportsMode) {
+						addInteropStatement(namespaceVariableName!, getDefaultOnlyHelper(), name);
+					}
+					break;
+				}
+			}
+		} else {
 			const moduleInterop = String(interop(id));
 			let hasDefault = false;
 			let hasNamespace = false;
 			for (const { imported, reexported } of [
 				...(imports || []),
 				...(reexports || [])
 			] as ReexportSpecifier[]) {
-				let helper: string | null = null;
-				let variableName;
+				let helper: string | undefined | null;
+				let variableName: string | undefined;
 				if (imported === 'default') {
 					if (!hasDefault) {
 						hasDefault = true;
 						if (defaultVariableName !== namespaceVariableName) {
-							variableName = defaultVariableName;
+							variableName = defaultVariableName!;
 							helper = defaultInteropHelpersByInteropType[moduleInterop];
 						}
 					}
 				} else if (imported === '*' && reexported !== '*') {
 					if (!hasNamespace) {
 						hasNamespace = true;
 						helper = namespaceInteropHelpersByInteropType[moduleInterop];
-						variableName = namespaceVariableName;
+						variableName = namespaceVariableName!;
 					}
 				}
 				if (helper) {
-					neededInteropHelpers.add(helper);
-					interopStatements.push(
-						`${varOrConst} ${variableName}${_}=${_}/*#__PURE__*/${helper}(${name});`
-					);
+					addInteropStatement(variableName!, helper, name);
 				}
 			}
 		}