rollup-plugin-concurrent-top-level-await 0.0.5 → 0.0.7

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

package/dist/index.d.mts

@@ -1,24 +1,23 @@
 import { FilterPattern } from "@rollup/pluginutils";
+import * as magic_string0 from "magic-string";
 import * as rollup0 from "rollup";
 
 //#region src/index.d.ts
 declare function concurrentTopLevelAwait(options?: {
   include?: FilterPattern;
   exclude?: FilterPattern;
+  sourceMap?: boolean;
 }): {
   name: string;
   apply: "build";
   transform: {
     handler(this: rollup0.TransformPluginContext, code: string, id: string): Promise<{
       code: string;
-      meta: {
-        async: true;
-      };
+      map: magic_string0.SourceMap | null;
     } | undefined>;
   };
   resolveImportMeta(this: rollup0.PluginContext, property: string | null, {
-    moduleId,
-    chunkId
+    moduleId
   }: {
     chunkId: string;
     format: rollup0.InternalModuleFormat;

package/dist/index.mjs

@@ -31,69 +31,92 @@ function withResolvers() {
 }
 
 //#endregion
-//#region src/AsyncTlaTracker.ts
+//#region src/AsyncModuleTracker.ts
 var AwaitableCache = class {
 	#store = /* @__PURE__ */ new Map();
 	#getPromise(key) {
 		const entry = this.#store.get(key);
 		if (entry) return entry;
-		const { promise, resolve } = withResolvers();
-		this.#store.set(key, [promise, resolve]);
-		return [promise, resolve];
+		const { promise, resolve, reject } = withResolvers();
+		this.#store.set(key, [
+			promise,
+			resolve,
+			reject
+		]);
+		return [
+			promise,
+			resolve,
+			reject
+		];
 	}
-	set(key, value) {
+	resolve(key, value) {
 		const [_, resolve] = this.#getPromise(key);
 		resolve(value);
 	}
+	reject(key) {
+		const [_, __, reject] = this.#getPromise(key);
+		reject();
+	}
 	get(key) {
 		const [promise] = this.#getPromise(key);
 		return promise;
 	}
 };
-var AsyncTlaTracker = class {
-	#all = /* @__PURE__ */ new Set();
-	#unseen = /* @__PURE__ */ new Set();
-	#unresolved = /* @__PURE__ */ new Set();
-	#resultCache = new AwaitableCache();
-	get(key) {
-		return this.#resultCache.get(key);
+/**
+* AsyncModuleTracker tracks whether modules must be treated as async due to
+* containing top-level await or being an ancestor of an async module.
+*/
+var AsyncModuleTracker = class {
+	#entryCache = new AwaitableCache();
+	#subtreeCache = new AwaitableCache();
+	#resultCache = /* @__PURE__ */ new Map();
+	#seen = /* @__PURE__ */ new Set();
+	#resolved = /* @__PURE__ */ new Set();
+	#childrenSeen = /* @__PURE__ */ new Set();
+	#cycleResolver;
+	#resolveCycles;
+	constructor() {
+		this.#createCycleResolver();
 	}
-	setMarked(key, value) {
-		this.#all.add(key);
-		this.#unseen.delete(key);
-		this.#unresolved.delete(key);
-		this.#resultCache.set(key, true);
-		setTimeout(() => {
-			if (this.#unseen.size == 0) {
-				this.#unresolved.forEach((e) => this.#resultCache.set(e, false));
-				this.#all.forEach((e) => this.#resultCache.set(e, false));
-				this.#unresolved.clear();
-			}
-		}, 0);
+	#createCycleResolver() {
+		const { promise, resolve } = withResolvers();
+		this.#cycleResolver = promise;
+		this.#resolveCycles = () => resolve(false);
 	}
-	setChildren(key, children) {
-		if (!this.#all.has(key)) {
-			this.#all.add(key);
-			this.#unresolved.add(key);
-		}
-		this.#unseen.delete(key);
-		children.forEach((children$1) => {
-			if (!this.#all.has(children$1)) {
-				this.#all.add(children$1);
-				this.#unresolved.add(key);
-				this.#unseen.add(children$1);
-			}
-			this.#resultCache.get(children$1).then((value) => {
-				if (value) this.setMarked(key, true);
+	#checkForCycles() {
+		if (this.#childrenSeen.size === this.#seen.size && this.#resolved.size === this.#seen.size) {
+			const resolveCycles = this.#resolveCycles;
+			this.#createCycleResolver();
+			setTimeout(() => {
+				resolveCycles();
 			});
+		}
+	}
+	#bindResultCache(key) {
+		if (!this.#resultCache.has(key)) this.#resultCache.set(key, this.#subtreeCache.get(key).then(() => false).catch(() => true));
+	}
+	isAsync(key) {
+		this.#bindResultCache(key);
+		return this.#resultCache.get(key);
+	}
+	setEntryAsync(key, value) {
+		this.#seen.add(key);
+		this.#resolved.add(key);
+		if (value) {
+			this.#entryCache.reject(key);
+			this.#entryCache.get(key).catch(() => {});
+		} else this.#entryCache.resolve(key, void 0);
+		this.#checkForCycles();
+	}
+	setDependencies(key, children) {
+		this.#seen.add(key);
+		this.#childrenSeen.add(key);
+		children.forEach((child) => {
+			this.#seen.add(child);
 		});
-		setTimeout(() => {
-			if (this.#unseen.size == 0) {
-				this.#unresolved.forEach((e) => this.#resultCache.set(e, false));
-				this.#all.forEach((e) => this.#resultCache.set(e, false));
-				this.#unresolved.clear();
-			}
-		}, 0);
+		Promise.race([this.#cycleResolver, Promise.all([this.#entryCache.get(key), ...children.map((child) => this.#subtreeCache.get(child))])]).then(() => this.#subtreeCache.resolve(key, void 0)).catch(() => this.#subtreeCache.reject(key));
+		this.#bindResultCache(key);
+		this.#checkForCycles();
 	}
 };
 
@@ -136,10 +159,11 @@ 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);
+		if (node.type === "VariableDeclaration") if (node.kind.endsWith("using")) s = moveVariableDeclarationWithUsingToModuleScope(s, node, moduleScopeEnd);
+		else s = moveVariableDeclarationToModuleScope(s, node, moduleScopeEnd);
 		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);
@@ -150,15 +174,26 @@ 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, "(");
+	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);
 	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;
@@ -183,41 +218,41 @@ function getNames(pattern) {
 //#region src/index.ts
 function concurrentTopLevelAwait(options = {}) {
 	const filter = createFilter(options.include, options.exclude);
-	const asyncTree = new AsyncTlaTracker();
+	const asyncTracker = new AsyncModuleTracker();
 	return {
 		name: "rollup-plugin-concurrent-tla-plugin",
 		apply: "build",
 		transform: { async handler(code, id) {
 			if (!filter(id)) return;
-			const ast = this.parse(code, { jsx: false });
+			const ast = this.parse(code);
 			const importDeclarations = ast.body.filter((a) => a.type === "ImportDeclaration");
 			const hasAwait = hasTopLevelAwait(ast);
-			if (hasAwait) asyncTree.setMarked(id, true);
+			asyncTracker.setEntryAsync(id, hasAwait);
+			if (hasAwait) asyncTracker.setDependencies(id, []);
 			else {
 				const childrenIds = (await Promise.all(importDeclarations.map(async (declaration) => {
 					const importId = await this.resolve(declaration.source.value, id);
 					if (!importId || !filter(importId.id)) return null;
 					return importId.id;
 				}))).filter((a) => a != null);
-				asyncTree.setChildren(id, childrenIds);
+				asyncTracker.setDependencies(id, childrenIds);
 			}
 			const asyncImports = (await Promise.all(importDeclarations.map(async (declaration) => {
 				const importId = await this.resolve(declaration.source.value, id);
 				if (!importId || !filter(importId.id)) return null;
 				this.load(importId);
-				if (!await asyncTree.get(importId.id)) return null;
+				if (!await asyncTracker.isAsync(importId.id)) return null;
 				return declaration;
 			}))).filter(Boolean);
-			const isAsyncModule = asyncImports.length > 0 || hasAwait;
-			if (!isAsyncModule) return;
+			if (!(asyncImports.length > 0 || hasAwait)) return;
 			let s = new MagicString(code);
 			s = transform(s, ast, asyncImports, hasAwait);
 			return {
 				code: s.toString(),
-				meta: { async: isAsyncModule }
+				map: options.sourceMap !== false ? s.generateMap({ hires: true }) : null
 			};
 		} },
-		resolveImportMeta(property, { moduleId, chunkId }) {
+		resolveImportMeta(property, { moduleId }) {
 			if (property !== "useTla") return;
 			const moduleInfo = this.getModuleInfo(moduleId);
 			const importers = moduleInfo?.importers;

package/package.json

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