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

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();
 	}
 };
 
@@ -153,7 +176,7 @@ function isDeclaration(type) {
 function moveVarDeclarationToModuleScope(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);
@@ -183,41 +206,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.6",
   "description": "Rollup (and Vite) plugin enabling concurrent execution of modules that contain top level await.",
   "keywords": [
     "rollup-plugin",