rollup-plugin-concurrent-top-level-await 0.0.9 → 0.2.0

package/README.md

@@ -30,7 +30,16 @@ export default {
 };
 ```
 
-### Which modules to include
+## Options
+
+| Option                    | Type            | Default     | Description                                                                                                                       |
+| ------------------------- | --------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `include`                 | `FilterPattern` | `undefined` | A pattern specifying which files to include. See [below](#which-modules-to-include) to determine which modules to include.        |
+| `exclude`                 | `FilterPattern` | `undefined` | A pattern specifying which files to exclude. Must still follow the [same considerations](#which-modules-to-include) as `include`. |
+| `sourceMap`               | `boolean`       | `true`      | Whether to generate source maps for transformed files.                                                                            |
+| `generatedVariablePrefix` | `string`        | `"__tla"`   | Prefix used for internal variables generated by the plugin. Change this if it conflicts with variable names in your code.         |
+
+### Which modules to include?
 
 The plugin needs to handle not only modules that directly contain a top-level `await`, but also their ancestor modules up to the lowest common ancestor. Ancestor modules must be transformed to handle the asynchronous completion of their children concurrently. As an example, consider the following module structure:
 
@@ -90,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
@@ -97,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

@@ -7,6 +7,12 @@ declare function concurrentTopLevelAwait(options?: {
   include?: FilterPattern;
   exclude?: FilterPattern;
   sourceMap?: boolean;
+  /**
+   * Prefix used for internal variables generated by the plugin.
+   * Change this if it conflicts with variable names in your code.
+   * @default "__tla"
+   */
+  generatedVariablePrefix?: string;
 }): {
   name: string;
   apply: "build";

package/dist/index.mjs

@@ -128,84 +128,96 @@ var AsyncModuleTracker = class {
 
 //#endregion
 //#region src/transform.ts
-function transform(s, ast, asyncImports, hasAwait) {
-	let declarationsEnd;
-	[s, declarationsEnd] = tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports);
-	s = s.appendRight(declarationsEnd, ";\nasync function __exec() {\n");
-	s = s.append("}\n");
-	const tlas = `[${asyncImports.map((_, i) => `__tla${i}`).join()}].flatMap(a => {
-        try {
-            const result = a();
-            if (Array.isArray(result)) {
-                return result
-            }
-            return [a];
-        } catch {
-            return []; // happens for cyclic dependencies
-        }
-    })`;
-	const execWrapper = asyncImports.length === 0 ? "__exec();" : `Promise.all(${tlas}.map(e => e())).then(() => __exec());`;
-	if (hasAwait) s = s.append(`const __tla = ${execWrapper}; const __todo = __tla;`);
-	else s = s.append(`const __tla = ${tlas};
-            const __todo = ${execWrapper};`);
-	s = s.append("if (import.meta.useTla) await __todo;");
-	s = s.append("export function __tla_access() { return __tla; };");
-	return s;
+function transform(s, ast, asyncImports, hasAwait, 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 => {
+	try {
+		const result = a();
+		if (Array.isArray(result)) {
+			return result
+		}
+		return [a];
+	} catch {
+		return []; // happens for cyclic dependencies
+	}
+})`;
+	const initModuleExportsAfterDeps = asyncImports.length === 0 ? `${variablePrefix}_initModuleExports()` : `Promise.all(${asyncDeps}.map(e => e())).then(() => ${variablePrefix}_initModuleExports())`;
+	if (hasAwait) s.append(`const ${variablePrefix} = ${initModuleExportsAfterDeps};\nconst ${variablePrefix}_initPromise = ${variablePrefix};\n`);
+	else s.append(`const ${variablePrefix} = ${asyncDeps};\nconst ${variablePrefix}_initPromise = ${initModuleExportsAfterDeps};\n`);
+	s.append(`if (import.meta.useTla) await ${variablePrefix}_initPromise;\n`);
+	s.append(`export function ${variablePrefix}_access() { return ${variablePrefix}; };\n`);
 }
-function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports) {
+function transformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix) {
 	let moduleScopeEnd = 0;
 	let i = 0;
 	for (const node of ast.body) {
 		if (asyncImports.includes(node)) {
-			const tlaImport = `;import { __tla_access as __tla${i}} from '${node.source.value}';`;
-			s = s.appendLeft(node.end, tlaImport);
+			const tlaImport = `\nimport { ${variablePrefix}_access as ${variablePrefix}${i}} from '${node.source.value}';`;
+			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 = s.appendLeft(moduleScopeEnd, ";export ");
-				s = s.remove(node.start, node.declaration.start);
-				s = moveVariableDeclarationToModuleScope(s, node.declaration, moduleScopeEnd);
+				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")) s = moveVariableDeclarationWithUsingToModuleScope(s, node, moduleScopeEnd);
-		else s = moveVariableDeclarationToModuleScope(s, node, moduleScopeEnd);
+		} else if (node.type === "VariableDeclaration") if (node.kind.endsWith("using")) moveVariableDeclarationWithUsingToModuleScope(s, node, moduleScopeEnd, variablePrefix);
+		else moveVariableDeclarationToModuleScope(s, node, moduleScopeEnd);
 		else visitScope(node, (n) => {
-			if (n.type === "VariableDeclaration" && n.kind === "var") s = moveVariableDeclarationToModuleScope(s, n, moduleScopeEnd);
+			if (n.type === "VariableDeclaration" && n.kind === "var") moveVariableDeclarationToModuleScope(s, n, moduleScopeEnd);
 			return false;
 		});
-		if (node.type === "ExportDefaultDeclaration" && !isDeclaration(node.declaration.type)) {
-			s = s.appendLeft(moduleScopeEnd, "let __tla_default;\nexport { __tla_default as default };\n");
-			s = s.remove(node.start, node.declaration.start);
-			s = s.appendRight(node.declaration.start, ";__tla_default = (");
-			s = s.appendLeft(node.declaration.end, ");");
+		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) {
-			s = s.appendRight(node.start, ";\n");
-			s = s.move(node.start, node.end, 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, ";");
 		} else moduleScopeEnd = node.end;
 	}
-	return [s, moduleScopeEnd];
+	return moduleScopeEnd;
+}
+function isFunctionDeclaration(type) {
+	return type === "FunctionDeclaration";
 }
-function isDeclaration(type) {
-	return type === "ClassDeclaration" || type === "FunctionDeclaration";
+function getClassDeclarationStart(node) {
+	return node.decorators[0]?.start ?? node.start;
 }
 function moveVariableDeclarationToModuleScope(s, node, declarationsEnd) {
 	const kind = replaceConstWithLet(node.kind);
 	const names = node.declarations.flatMap((decl) => getNames(decl.id)).join(", ");
-	s = s.appendRight(node.declarations[0].start, ";(");
-	s = s.appendLeft(node.declarations[node.declarations.length - 1].end, ")");
-	s = s.appendLeft(declarationsEnd, `\n${kind} ${names};\n`);
-	s = s.remove(node.start, node.declarations[0].start);
+	s.appendRight(node.declarations[0].start, ";(");
+	s.appendLeft(node.declarations[node.declarations.length - 1].end, ")");
+	s.appendLeft(declarationsEnd, `${kind} ${names};\n`);
+	s.remove(node.start, node.declarations[0].start);
 	return s;
 }
-function moveVariableDeclarationWithUsingToModuleScope(s, node, declarationsEnd) {
+function moveVariableDeclarationWithUsingToModuleScope(s, node, declarationsEnd, variablePrefix) {
 	node.declarations.forEach((declaration) => {
 		const id = declaration.id;
 		if (id.type !== "Identifier") throw new Error("'using' declarations may not have binding patterns.");
 		const name = id.name;
-		s = s.appendRight(id.start, `__tla_using_`);
-		s = s.appendLeft(node.end, `;\n${name} = __tla_using_${name};`);
-		s = s.appendLeft(declarationsEnd, `\nlet ${name};\n`);
+		s.appendRight(id.start, `${variablePrefix}_using_`);
+		s.appendLeft(node.end, `\n${name} = ${variablePrefix}_using_${name};`);
+		s.appendLeft(declarationsEnd, `let ${name};\n`);
 	});
 	return s;
 }
@@ -260,8 +272,8 @@ function concurrentTopLevelAwait(options = {}) {
 				return declaration;
 			}))).filter(Boolean);
 			if (!(asyncImports.length > 0 || hasAwait)) return;
-			let s = new MagicString(code);
-			s = transform(s, ast, asyncImports, hasAwait);
+			const s = new MagicString(code);
+			transform(s, ast, asyncImports, hasAwait, options.generatedVariablePrefix ?? "__tla");
 			return {
 				code: s.toString(),
 				map: options.sourceMap !== false ? s.generateMap({ hires: true }) : null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-concurrent-top-level-await",
-  "version": "0.0.9",
+  "version": "0.2.0",
   "description": "Rollup (and Vite) plugin enabling concurrent execution of modules that contain top level await.",
   "keywords": [
     "rollup-plugin",