rollup-plugin-concurrent-top-level-await 0.1.0 → 0.2.1

package/README.md

@@ -99,6 +99,14 @@ postponed until the subgraph is analyzed. This may lead to slower builds.
 
 If you notice significant performance degradation, please open an issue.
 
+### Exposed Module Structure
+
+Because the execution of modules gets wrapped in functions, the bundled output will contain more information about the source module structure. This may be a consideration for projects where code obfuscation is important.
+
+### Tree Shaking
+
+Wrapping code in functions may reduce tree shaking effectiveness. We mitigate this where possible, such as by not wrapping declarations.
+
 ### Changing Variable Types
 
 In the process of transforming the code, top level `const` declarations may get replaced with `let` declarations. This
@@ -106,7 +114,6 @@ can lead to `const` variables being assignable at runtime instead of throwing an
 
 Additionally, variable declarations may be hoisted, which removes temporal dead zone (TDZ) checks.
 
-### Class Decorators
+### Default export class name
 
-Class declarations still get evaluated before any top level await expressions. This means that if a class decorator
-relies on a top level await expression, it may not work as expected.
+When using `export default class {}`, the runtime `.name` of the exported value will be `<generatedVariablePrefix>_default` (e.g. `__tla_default`) instead of `default`.

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { FilterPattern } from "@rollup/pluginutils";
 import * as magic_string0 from "magic-string";
 import * as rollup0 from "rollup";
+import { TransformPluginContext } from "rollup";
 
 //#region src/index.d.ts
 declare function concurrentTopLevelAwait(options?: {
@@ -17,7 +18,10 @@ declare function concurrentTopLevelAwait(options?: {
   name: string;
   apply: "build";
   transform: {
-    handler(this: rollup0.TransformPluginContext, code: string, id: string): Promise<{
+    handler(this: TransformPluginContext, code: string, id: string, transformOptions: {
+      ssr?: boolean | undefined;
+      attributes?: Record<string, string>;
+    } | undefined): Promise<{
       code: string;
       map: magic_string0.SourceMap | null;
     } | undefined>;
@@ -25,6 +29,7 @@ declare function concurrentTopLevelAwait(options?: {
   resolveImportMeta(this: rollup0.PluginContext, property: string | null, {
     moduleId
   }: {
+    attributes: Record<string, string>;
     chunkId: string;
     format: rollup0.InternalModuleFormat;
     moduleId: string;

package/dist/index.mjs

@@ -129,7 +129,7 @@ var AsyncModuleTracker = class {
 //#endregion
 //#region src/transform.ts
 function transform(s, ast, asyncImports, hasAwait, variablePrefix) {
-	const declarationsEnd = tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix);
+	const declarationsEnd = transformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix);
 	s.appendRight(declarationsEnd, `async function ${variablePrefix}_initModuleExports() {\n`);
 	s.append("\n}\n");
 	const asyncDeps = `[${asyncImports.map((_, i) => `${variablePrefix}${i}`).join()}].flatMap(a => {
@@ -149,7 +149,7 @@ function transform(s, ast, asyncImports, hasAwait, variablePrefix) {
 	s.append(`if (import.meta.useTla) await ${variablePrefix}_initPromise;\n`);
 	s.append(`export function ${variablePrefix}_access() { return ${variablePrefix}; };\n`);
 }
-function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix) {
+function transformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix) {
 	let moduleScopeEnd = 0;
 	let i = 0;
 	for (const node of ast.body) {
@@ -158,11 +158,20 @@ function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variable
 			s.appendLeft(node.end, tlaImport);
 			i++;
 		}
+		if (node.type === "ClassDeclaration") {
+			s.appendLeft(moduleScopeEnd, `let ${node.id.name};\n`);
+			s.appendRight(node.start, `${node.id.name} = `);
+		}
 		if (node.type === "ExportNamedDeclaration") {
 			if (node.declaration?.type === "VariableDeclaration") {
 				s.appendLeft(moduleScopeEnd, "export ");
 				s.remove(node.start, node.declaration.start);
 				moveVariableDeclarationToModuleScope(s, node.declaration, moduleScopeEnd);
+			} else if (node.declaration?.type === "ClassDeclaration") {
+				s.appendLeft(moduleScopeEnd, `export let ${node.declaration.id.name};\n`);
+				const declarationStart = getClassDeclarationStart(node.declaration);
+				s.remove(node.start, declarationStart);
+				s.appendRight(declarationStart, `${node.declaration.id.name} = `);
 			}
 		} else if (node.type === "VariableDeclaration") if (node.kind.endsWith("using")) moveVariableDeclarationWithUsingToModuleScope(s, node, moduleScopeEnd, variablePrefix);
 		else moveVariableDeclarationToModuleScope(s, node, moduleScopeEnd);
@@ -170,13 +179,15 @@ function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variable
 			if (n.type === "VariableDeclaration" && n.kind === "var") moveVariableDeclarationToModuleScope(s, n, moduleScopeEnd);
 			return false;
 		});
-		if (node.type === "ExportDefaultDeclaration" && !isDeclaration(node.declaration.type)) {
-			s.appendLeft(moduleScopeEnd, `let ${variablePrefix}_default;\nexport { ${variablePrefix}_default as default };\n`);
-			s.remove(node.start, node.declaration.start);
-			s.appendRight(node.declaration.start, `${variablePrefix}_default = (`);
+		if (node.type === "ExportDefaultDeclaration" && !isFunctionDeclaration(node.declaration.type)) {
+			const variableName = node.declaration.type === "ClassDeclaration" ? node.declaration.id?.name ?? `${variablePrefix}_default` : `${variablePrefix}_default`;
+			s.appendLeft(moduleScopeEnd, `let ${variableName};\nexport { ${variableName} as default };\n`);
+			const declarationStart = node.declaration.type === "ClassDeclaration" ? getClassDeclarationStart(node.declaration) : node.declaration.start;
+			s.remove(node.start, declarationStart);
+			s.appendRight(declarationStart, `${variableName} = (`);
 			s.appendLeft(node.declaration.end, ");");
 		}
-		if (isDeclaration(node.type) || node.type === "ImportDeclaration" || node.type === "ExportDefaultDeclaration" && isDeclaration(node.declaration.type) || node.type === "ExportNamedDeclaration" && isDeclaration(node.declaration?.type) || node.type === "ExportNamedDeclaration" && node.declaration == null || node.type === "ExportAllDeclaration") if (node.start > moduleScopeEnd) {
+		if (isFunctionDeclaration(node.type) || node.type === "ImportDeclaration" || node.type === "ExportDefaultDeclaration" && isFunctionDeclaration(node.declaration.type) || node.type === "ExportNamedDeclaration" && isFunctionDeclaration(node.declaration?.type) || node.type === "ExportNamedDeclaration" && node.declaration == null || node.type === "ExportAllDeclaration") if (node.start > moduleScopeEnd) {
 			s.appendLeft(node.end, "\n");
 			s.move(node.start, node.end, moduleScopeEnd);
 			s.appendLeft(node.start, ";");
@@ -184,8 +195,11 @@ function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variable
 	}
 	return moduleScopeEnd;
 }
-function isDeclaration(type) {
-	return type === "ClassDeclaration" || type === "FunctionDeclaration";
+function isFunctionDeclaration(type) {
+	return type === "FunctionDeclaration";
+}
+function getClassDeclarationStart(node) {
+	return node.decorators[0]?.start ?? node.start;
 }
 function moveVariableDeclarationToModuleScope(s, node, declarationsEnd) {
 	const kind = replaceConstWithLet(node.kind);
@@ -229,13 +243,20 @@ function getNames(pattern) {
 
 //#endregion
 //#region src/index.ts
+function resolveDeclarationSource(context, id, importerAttributes = {}, declaration) {
+	return context.resolve(declaration.source.value, id, {
+		attributes: Object.fromEntries(declaration.attributes.map((attr) => [attr.key.type === "Identifier" ? attr.key.name : attr.key.value, attr.value.value])),
+		importerAttributes,
+		custom: {}
+	});
+}
 function concurrentTopLevelAwait(options = {}) {
 	const filter = createFilter(options.include, options.exclude);
 	const asyncTracker = new AsyncModuleTracker();
 	return {
 		name: "rollup-plugin-concurrent-tla-plugin",
 		apply: "build",
-		transform: { async handler(code, id) {
+		transform: { async handler(code, id, transformOptions) {
 			if (!filter(id)) return;
 			const ast = this.parse(code);
 			const importDeclarations = ast.body.filter((a) => a.type === "ImportDeclaration");
@@ -244,14 +265,14 @@ function concurrentTopLevelAwait(options = {}) {
 			if (hasAwait) asyncTracker.setDependencies(id, []);
 			else {
 				const childrenIds = (await Promise.all(importDeclarations.map(async (declaration) => {
-					const importId = await this.resolve(declaration.source.value, id);
+					const importId = await resolveDeclarationSource(this, id, transformOptions?.attributes, declaration);
 					if (!importId || !filter(importId.id)) return null;
 					return importId.id;
 				}))).filter((a) => a != null);
 				asyncTracker.setDependencies(id, childrenIds);
 			}
 			const asyncImports = (await Promise.all(importDeclarations.map(async (declaration) => {
-				const importId = await this.resolve(declaration.source.value, id);
+				const importId = await resolveDeclarationSource(this, id, transformOptions?.attributes, declaration);
 				if (!importId || !filter(importId.id)) return null;
 				this.load(importId);
 				if (!await asyncTracker.isAsync(importId.id)) return null;
@@ -268,9 +289,9 @@ function concurrentTopLevelAwait(options = {}) {
 		resolveImportMeta(property, { moduleId }) {
 			if (property !== "useTla") return;
 			const moduleInfo = this.getModuleInfo(moduleId);
-			const importers = moduleInfo?.importers;
-			if (moduleInfo?.isEntry || !importers?.length) return "true";
-			if (importers.some((id) => !filter(id))) return "true";
+			if (moduleInfo?.isEntry) return "true";
+			if (moduleInfo?.dynamicImporters.length) return "true";
+			if ((moduleInfo?.importers)?.some((id) => !filter(id))) return "true";
 			return "false";
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-concurrent-top-level-await",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Rollup (and Vite) plugin enabling concurrent execution of modules that contain top level await.",
   "keywords": [
     "rollup-plugin",
@@ -46,7 +46,8 @@
   },
   "devDependencies": {
     "@types/estree": "^1.0.8",
-    "prettier": "3.7.4"
+    "prettier": "3.7.4",
+    "rollup": "^4.57.1"
   },
   "scripts": {
     "build": "tsdown --dts"