Separate namespace inclusion tracking per output, handle dynamic impo…

…rts of synthetic namespace modules

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);
@@ -219,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;
 			}
@@ -235,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);
 					}
 				}
@@ -360,6 +366,7 @@ export default class Chunk {
 						this.modulesById,
 						this.chunkByModule,
 						this.facadeChunkByModule,
+						this.includedNamespaces,
 						module,
 						facadeName
 					)
@@ -380,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);
 			}
 		}
@@ -582,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) {
@@ -592,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));
@@ -1260,7 +1267,8 @@ export default class Chunk {
 			this.chunkByModule,
 			syntheticExports,
 			this.exportNamesByVariable,
-			this.accessedGlobalsByScope
+			this.accessedGlobalsByScope,
+			this.includedNamespaces
 		);
 	}
 
@@ -1269,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]);
 				}
@@ -1296,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)
 		) {
@@ -1307,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,14 +529,14 @@ 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()) {
-			if (exportName !== this.syntheticNamedExports) {
+			if (includeNamespaceMembers || exportName !== this.syntheticNamedExports) {
 				const variable = this.getVariableForExportName(exportName);
 				variable.deoptimizePath(UNKNOWN_PATH);
 				if (!variable.included) {
@@ -557,6 +557,10 @@ export default class Module {
 				variable.module.reexported = true;
 			}
 		}
+
+		if (includeNamespaceMembers) {
+			this.namespace.prepareNamespace(this.includeAndGetAdditionalMergedNamespaces());
+		}
 	}
 
 	includeAllInBundle() {
@@ -681,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,
@@ -928,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,23 @@ 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.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/getInteropBlock.ts

@@ -61,8 +61,8 @@ export default function getInteropBlock(
 				...(imports || []),
 				...(reexports || [])
 			] as ReexportSpecifier[]) {
-				let helper: string | null = null;
-				let variableName: string;
+				let helper: string | undefined | null;
+				let variableName: string | undefined;
 				if (imported === 'default') {
 					if (!hasDefault) {
 						hasDefault = true;
@@ -79,7 +79,7 @@ export default function getInteropBlock(
 					}
 				}
 				if (helper) {
-					addInteropStatement(variableName, helper, name);
+					addInteropStatement(variableName!, helper, name);
 				}
 			}
 		}

src/utils/deconflictChunk.ts

@@ -52,7 +52,8 @@ export function deconflictChunk(
 	chunkByModule: Map<Module, Chunk>,
 	syntheticExports: Set<SyntheticNamedExportVariable>,
 	exportNamesByVariable: Map<Variable, string[]>,
-	accessedGlobalsByScope: Map<ChildScope, Set<string>>
+	accessedGlobalsByScope: Map<ChildScope, Set<string>>,
+	includedNamespaces: Set<Module>
 ) {
 	for (const module of modules) {
 		module.scope.addUsedOutsideNames(
@@ -62,7 +63,7 @@ export function deconflictChunk(
 			accessedGlobalsByScope
 		);
 	}
-	deconflictTopLevelVariables(usedNames, modules);
+	deconflictTopLevelVariables(usedNames, modules, includedNamespaces);
 	DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](
 		usedNames,
 		imports,
@@ -201,7 +202,11 @@ function deconflictImportsOther(
 	}
 }
 
-function deconflictTopLevelVariables(usedNames: Set<string>, modules: Module[]) {
+function deconflictTopLevelVariables(
+	usedNames: Set<string>,
+	modules: Module[],
+	includedNamespaces: Set<Module>
+) {
 	for (const module of modules) {
 		for (const variable of module.scope.variables.values()) {
 			if (
@@ -215,8 +220,8 @@ function deconflictTopLevelVariables(usedNames: Set<string>, modules: Module[])
 				variable.setRenderNames(null, getSafeName(variable.name, usedNames));
 			}
 		}
-		const namespace = module.namespace;
-		if (namespace.included) {
+		if (includedNamespaces.has(module)) {
+			const namespace = module.namespace;
 			namespace.setRenderNames(null, getSafeName(namespace.name, usedNames));
 		}
 	}

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_config.js

@@ -0,0 +1,18 @@
+module.exports = {
+	description:
+		'handle dynamically importing a module with synthetic named exports when preserving modules',
+	options: {
+		input: ['main', 'lib'],
+		plugins: {
+			name: 'test-plugin',
+			transform(code, id) {
+				if (id.endsWith('lib.js')) {
+					return { code, syntheticNamedExports: '__moduleExports' };
+				}
+			}
+		},
+		output: {
+			preserveModules: true
+		}
+	}
+};

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/amd/lib.js

@@ -0,0 +1,8 @@
+define(function () { 'use strict';
+
+	const __moduleExports = { foo: 'bar' };
+	var lib = 'baz';
+
+	return lib;
+
+});

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/amd/main.js

@@ -0,0 +1,9 @@
+define(['require'], function (require) { 'use strict';
+
+	function _interopNamespaceDefaultOnly(e) {
+		return Object.freeze({__proto__: null, 'default': e});
+	}
+
+	new Promise(function (resolve, reject) { require(['./lib'], function (m) { resolve(/*#__PURE__*/_interopNamespaceDefaultOnly(m)); }, reject) }).then(console.log);
+
+});

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/cjs/lib.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const __moduleExports = { foo: 'bar' };
+var lib = 'baz';
+
+module.exports = lib;

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/cjs/main.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function _interopNamespaceDefaultOnly(e) {
+	return Object.freeze({__proto__: null, 'default': e});
+}
+
+Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespaceDefaultOnly(require('./lib.js')); }).then(console.log);

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/es/lib.js

@@ -0,0 +1,4 @@
+const __moduleExports = { foo: 'bar' };
+var lib = 'baz';
+
+export default lib;

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/es/main.js

@@ -0,0 +1 @@
+import('./lib.js').then(console.log);

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/system/lib.js

@@ -0,0 +1,11 @@
+System.register([], function (exports) {
+	'use strict';
+	return {
+		execute: function () {
+
+			const __moduleExports = { foo: 'bar' };
+			var lib = exports('default', 'baz');
+
+		}
+	};
+});

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/_expected/system/main.js

@@ -0,0 +1,10 @@
+System.register([], function (exports, module) {
+	'use strict';
+	return {
+		execute: function () {
+
+			module.import('./lib.js').then(console.log);
+
+		}
+	};
+});

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/lib.js

@@ -0,0 +1,2 @@
+export const __moduleExports = { foo: 'bar' };
+export default 'baz';

test/chunking-form/samples/dynamic-import-synthetic-exports-preserve-modules/main.js

@@ -0,0 +1 @@
+import('./lib.js').then(console.log);