rollup-plugin-concurrent-top-level-await 0.0.6 → 0.0.8

package/README.md

@@ -24,12 +24,46 @@ import concurrentTopLevelAwait from "rollup-plugin-concurrent-top-level-await";
 export default {
 	plugins: [
 		concurrentTopLevelAwait({
-			include: "**/*.ts",
+			include: "**/*.js",
 		}),
 	],
 };
 ```
 
+### 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:
+
+```mermaid
+flowchart LR
+	app[app.js]
+	moduleA[moduleA.js]
+	moduleB[moduleB.js]
+	moduleC[moduleC.js]
+	tla1[tla1.js]
+	tla2[tla2.js]
+	tla3[tla3.js]
+	other[other.js]
+
+	app --> moduleA
+	moduleA --> moduleB
+	moduleA --> moduleC
+	moduleB --> tla1
+	moduleC --> tla2
+	moduleC --> tla3
+	app --> other
+
+	classDef tla fill:#ffe6e6,stroke:#ff0000,color:#660000
+	classDef ancestor fill:#fff4cc,stroke:#ffcc00,color:#663300
+	classDef unaffected fill:#e6ffe6,stroke:#00cc00,color:#006600
+
+	class tla1,tla2,tla3 tla
+	class moduleA,moduleB,moduleC ancestor
+	class app,other unaffected
+```
+
+If the red modules contain top level awaits, these and their yellow ancestors should be included in the plugin's `include` option.
+
 ## Known Limitations
 
 ### Execution Order
@@ -63,18 +97,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.
 
-### Exporting var
-
-The plugin only checks the very top level of a module for potentially exported variables. This means that if a `var`
-variable is declared inside a block but exported, the variable might not get handled correctly.
-
-```js
-if (something) {
-	var myValue = 42;
-}
-export default myValue;
-```
-
 ### Class Decorators
 
 Class declarations still get evaluated before any top level await expressions. This means that if a class decorator

package/dist/index.mjs

@@ -1,18 +1,24 @@
 import { createFilter } from "@rollup/pluginutils";
 import MagicString from "magic-string";
 
-//#region src/hasTopLevelAwait.ts
+//#region src/ast.ts
 function isFunctionNode(node) {
 	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "MethodDefinition" || node.type === "Property" && node.value.type === "FunctionExpression";
 }
+function visitScope(node, cb) {
+	if (node?.type == null) return false;
+	if (cb(node)) return true;
+	if (isFunctionNode(node)) return false;
+	return Object.values(node).flat().some((n) => visitScope(n, cb));
+}
+
+//#endregion
+//#region src/hasTopLevelAwait.ts
 function isAwaitNode(node) {
 	return node.type === "AwaitExpression" || node.type === "ForOfStatement" && node.await || node.type === "VariableDeclaration" && node.kind === "await using";
 }
-function hasTopLevelAwait(ast) {
-	if (ast?.type == null) return false;
-	if (isAwaitNode(ast)) return true;
-	if (isFunctionNode(ast)) return false;
-	return Object.values(ast).flat().some(hasTopLevelAwait);
+function hasTopLevelAwait(node) {
+	return visitScope(node, isAwaitNode);
 }
 
 //#endregion
@@ -159,10 +165,14 @@ function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports) {
 			if (node.declaration?.type === "VariableDeclaration") {
 				s = s.appendLeft(moduleScopeEnd, ";export ");
 				s = s.remove(node.start, node.declaration.start);
-				s = moveVarDeclarationToModuleScope(s, node.declaration, moduleScopeEnd);
+				s = moveVariableDeclarationToModuleScope(s, node.declaration, moduleScopeEnd);
 			}
-		}
-		if (node.type === "VariableDeclaration") s = moveVarDeclarationToModuleScope(s, node, moduleScopeEnd);
+		} else if (node.type === "VariableDeclaration") if (node.kind.endsWith("using")) s = moveVariableDeclarationWithUsingToModuleScope(s, node, moduleScopeEnd);
+		else s = moveVariableDeclarationToModuleScope(s, node, moduleScopeEnd);
+		else visitScope(node, (n) => {
+			if (n.type === "VariableDeclaration" && n.kind === "var") s = moveVariableDeclarationToModuleScope(s, n, moduleScopeEnd);
+			return false;
+		});
 		if (isDeclaration(node.type) || node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && isDeclaration(node.declaration?.type) || node.type === "ExportNamedDeclaration" && node.declaration == null || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") if (node.start > moduleScopeEnd) {
 			s = s.appendRight(node.start, ";\n");
 			s = s.move(node.start, node.end, moduleScopeEnd);
@@ -173,7 +183,7 @@ function tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports) {
 function isDeclaration(type) {
 	return type === "ClassDeclaration" || type === "FunctionDeclaration";
 }
-function moveVarDeclarationToModuleScope(s, node, declarationsEnd) {
+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, ";(");
@@ -182,6 +192,17 @@ function moveVarDeclarationToModuleScope(s, node, declarationsEnd) {
 	s = s.remove(node.start, node.declarations[0].start);
 	return s;
 }
+function moveVariableDeclarationWithUsingToModuleScope(s, node, declarationsEnd) {
+	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`);
+	});
+	return s;
+}
 function replaceConstWithLet(value) {
 	if (value === "const") return "let";
 	return value;

package/package.json

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