rolldown-plugin-concurrent-top-level-await 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Oliver Zell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/index.d.ts
+declare function concurrentTopLevelAwait(options?: {
+  /**
+   * Prefix used for internal variables generated by the plugin.
+   * Change this if it conflicts with variable names in your code.
+   * @default "__tla"
+   */
+  generatedVariablePrefix?: string;
+}): any[];
+//#endregion
+export { concurrentTopLevelAwait as default };

package/dist/index.mjs

@@ -0,0 +1,451 @@
+import { randomUUID } from "node:crypto";
+import { RolldownMagicString } from "rolldown";
+import { transform } from "rolldown/utils";
+
+//#region src/awaitEntriesPlugin.ts
+function awaitEntrypointsPlugin(options) {
+	const generatedVariablePrefix = options.generatedVariablePrefix;
+	const proxyPrefix = `\0${generatedVariablePrefix}AwaitEntry:`;
+	const awaitedEntriesMap = /* @__PURE__ */ new Map();
+	return {
+		name: "rolldown-plugin-concurrent-tla-plugin-await-entrypoints",
+		apply: "build",
+		resolveId: {
+			order: "pre",
+			async handler(source, importer, options$1) {
+				if (importer?.startsWith(proxyPrefix)) {
+					const key$1 = importer.slice(proxyPrefix.length);
+					const resolved$1 = awaitedEntriesMap.get(key$1);
+					if (!resolved$1) throw new Error("Name collision in concurrent-tla plugin, please change the generatedVariablePrefix option");
+					return resolved$1;
+				}
+				if (!options$1.isEntry && options$1.kind !== "dynamic-import") return;
+				const resolved = await this.resolve(source, importer, options$1);
+				if (resolved == null) return;
+				const key = randomUUID();
+				awaitedEntriesMap.set(key, resolved);
+				return `${proxyPrefix}${key}`;
+			}
+		},
+		load: {
+			order: "pre",
+			async handler(id) {
+				if (id.startsWith(proxyPrefix)) {
+					const resolved = awaitedEntriesMap.get(id.slice(proxyPrefix.length));
+					if (!resolved) throw new Error("Name collision in concurrent-tla plugin, please change the generatedVariablePrefix option");
+					if ((await this.load(resolved)).meta[generatedVariablePrefix + "_async"]) return `import { ${generatedVariablePrefix}_access } from "${resolved.id}";
+await new Promise(${generatedVariablePrefix}_access);
+export * from "${resolved.id}";
+`;
+					return `export * from "${resolved.id}";
+`;
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/registerModulePlugin.ts
+const tlaModule = `export default function register(fn, evaluate_accesses) {
+    let state = "ready";
+    let whenDones = [];
+    let whenErrors = [];
+    let remaining = 1;
+    let error = undefined;
+    // evaluate eagerly
+    evaluate();
+
+    return evaluate;
+
+    function evaluate(whenDone, onError) {
+        if (state === "done") {
+            if (whenDone)
+                whenDone();
+            return;
+        }
+        if (state === "failed") {
+            if (onError)
+                onError(error);
+            return;
+        }
+        if (whenDone)
+            whenDones.push(whenDone);
+        if (onError)
+            whenErrors.push(onError);
+        if (state === "busy") {
+            return;
+        }
+        state = "busy";
+        let moduleDone = () => {
+            state = "done";
+            for (let x of whenDones)
+                x();
+        };
+        let moduleError = (err) => {
+            state = "failed";
+            error = err;
+            for (let x of whenErrors)
+                x(err);
+        };
+        let importDone = () => {
+            if (state !== "busy")
+                return;
+            if (--remaining !== 0)
+                return;
+            try {
+                let result = fn();
+                if (result) {
+                    result
+                        .then(moduleDone)
+                        .catch(moduleError);
+                }
+                else {
+                    moduleDone();
+                }
+            }
+            catch (err) {
+                moduleError(err);
+            }
+        };
+        for (const access of evaluate_accesses) {
+            let evaluate;
+            try {
+                // Environment-dependent behavior:
+                // - throws on cyclic dependencies in V8
+                // - returns undefined in some environments (e.g., vitest)
+                evaluate = access();
+                if (evaluate == null)
+                    continue;
+            }
+            catch (_a) {
+                continue;
+            }
+            remaining++;
+            evaluate(importDone, moduleError);
+        }
+        importDone();
+    }
+}
+`;
+function registerModulePlugin(options) {
+	options.generatedVariablePrefix;
+	const registerModuleSource = options.registerModuleSource;
+	return {
+		name: "rolldown-plugin-concurrent-tla-plugin-register-module",
+		apply: "build",
+		resolveId(source) {
+			if (source === registerModuleSource) return registerModuleSource;
+		},
+		load(id) {
+			if (id === registerModuleSource) return tlaModule;
+		}
+	};
+}
+
+//#endregion
+//#region ../shared/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 ../shared/src/hasTopLevelAwait.ts
+function isAwaitNode(node) {
+	return node.type === "AwaitExpression" || node.type === "ForOfStatement" && node.await || node.type === "VariableDeclaration" && node.kind === "await using";
+}
+function hasTopLevelAwait(node) {
+	return visitScope(node, isAwaitNode);
+}
+
+//#endregion
+//#region ../shared/src/polyfills/promise.ts
+function withResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+
+//#endregion
+//#region ../shared/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, reject } = withResolvers();
+		this.#store.set(key, [
+			promise,
+			resolve,
+			reject
+		]);
+		return [
+			promise,
+			resolve,
+			reject
+		];
+	}
+	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;
+	}
+};
+/**
+* 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();
+	}
+	#createCycleResolver() {
+		const { promise, resolve } = withResolvers();
+		this.#cycleResolver = promise;
+		this.#resolveCycles = () => resolve(false);
+	}
+	#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);
+		});
+		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();
+	}
+};
+
+//#endregion
+//#region ../shared/src/transform.ts
+function transform$1(s, ast, registerModuleSource, asyncImports, hasAwait, variablePrefix) {
+	const declarationsEnd = transformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix);
+	s.appendRight(declarationsEnd, `${hasAwait ? "async " : ""}function ${variablePrefix}_initModuleExports() {\n`);
+	s.append("\n}\n");
+	s.prepend(`import ${variablePrefix}_register from ${JSON.stringify(registerModuleSource)};\n`);
+	const asyncDeps = `[${asyncImports.map((_, i) => `() => ${variablePrefix}${i}`).join(", ")}]`;
+	s.append(`export const ${variablePrefix}_access = ${variablePrefix}_register(${variablePrefix}_initModuleExports, ${asyncDeps});\n`);
+}
+function transformAndMoveDeclarationsToModuleScope(s, ast, asyncImports, variablePrefix) {
+	let moduleScopeEnd = 0;
+	let i = 0;
+	for (const node of ast.body) {
+		if (asyncImports.includes(node)) {
+			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.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);
+		else visitScope(node, (n) => {
+			if (n.type === "VariableDeclaration" && n.kind === "var") moveVariableDeclarationToModuleScope(s, n, moduleScopeEnd);
+			return false;
+		});
+		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 (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 moduleScopeEnd;
+}
+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);
+	const names = node.declarations.flatMap((decl) => getNames(decl.id)).join(", ");
+	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, 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.appendRight(id.start, `${variablePrefix}_using_`);
+		s.appendLeft(node.end, `\n${name} = ${variablePrefix}_using_${name};`);
+		s.appendLeft(declarationsEnd, `let ${name};\n`);
+	});
+	return s;
+}
+function replaceConstWithLet(value) {
+	if (value === "const") return "let";
+	return value;
+}
+function getNames(pattern) {
+	switch (pattern.type) {
+		case "Identifier": return [pattern.name];
+		case "MemberExpression": throw new Error("Unexpected member expression in variable declaration");
+		case "ObjectPattern": return pattern.properties.flatMap((p) => {
+			switch (p.type) {
+				case "Property": return getNames(p.value);
+				case "RestElement": return getNames(p.argument);
+			}
+		});
+		case "ArrayPattern": return pattern.elements.filter((e) => e != null).flatMap(getNames);
+		case "RestElement": return getNames(pattern.argument);
+		case "AssignmentPattern": return getNames(pattern.left);
+	}
+}
+
+//#endregion
+//#region src/transformPlugin.ts
+const supportedModuleTypes = new Set([
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+]);
+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 transformPlugin(options) {
+	const generatedVariablePrefix = options.generatedVariablePrefix;
+	const asyncTracker = new AsyncModuleTracker();
+	return {
+		name: "rolldown-plugin-concurrent-tla-plugin-transform",
+		apply: "build",
+		transform: { async handler(_code, id, transformOptions) {
+			if (id.startsWith(`\0${generatedVariablePrefix}AwaitEntry:`)) return;
+			if (!supportedModuleTypes.has(transformOptions?.moduleType)) {
+				asyncTracker.setEntryAsync(id, false);
+				asyncTracker.setDependencies(id, []);
+			}
+			const code = (await transform(id, _code)).code;
+			const ast = this.parse(code);
+			const importDeclarations = ast.body.filter((a) => a.type === "ImportDeclaration");
+			const hasAwait = hasTopLevelAwait(ast);
+			asyncTracker.setEntryAsync(id, hasAwait);
+			if (hasAwait) asyncTracker.setDependencies(id, []);
+			let imports = (await Promise.all(importDeclarations.map(async (declaration) => {
+				const importId = await resolveDeclarationSource(this, id, transformOptions?.attributes, declaration);
+				if (!importId) return null;
+				return {
+					declaration,
+					id: importId.id
+				};
+			}))).filter(Boolean);
+			if (!hasAwait) asyncTracker.setDependencies(id, imports.map((x) => x.id));
+			const asyncImports = (await Promise.all(imports.map(async ({ declaration, id: id$1 }) => {
+				this.load({ id: id$1 });
+				if (!await asyncTracker.isAsync(id$1)) return null;
+				return declaration;
+			}))).filter(Boolean);
+			if (!(asyncImports.length > 0 || hasAwait)) return;
+			const { magicString: _magicString } = transformOptions;
+			const magicString = new RolldownMagicString(code);
+			if (!_magicString) throw new Error("experimental.nativeMagicString must be enabled in the Rolldown options to use the concurrent-tla plugin");
+			transform$1(magicString, ast, options.registerModuleSource, asyncImports, hasAwait, generatedVariablePrefix);
+			return {
+				code: magicString,
+				meta: { [generatedVariablePrefix + "_async"]: true }
+			};
+		} }
+	};
+}
+
+//#endregion
+//#region src/index.ts
+function concurrentTopLevelAwait(options = {}) {
+	const generatedVariablePrefix = options.generatedVariablePrefix ?? "__tla";
+	const enrichedOptions = {
+		...options,
+		generatedVariablePrefix,
+		registerModuleSource: `\0${generatedVariablePrefix}Register`
+	};
+	return [
+		awaitEntrypointsPlugin(enrichedOptions),
+		registerModulePlugin(enrichedOptions),
+		transformPlugin(enrichedOptions)
+	];
+}
+
+//#endregion
+export { concurrentTopLevelAwait as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-concurrent-top-level-await",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Rolldown (and Vite) plugin enabling concurrent execution of modules that contain top level await.",
   "keywords": [
     "rolldown-plugin",
@@ -22,9 +22,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsdown --dts"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zOadT/concurrent-top-level-await-plugins.git"
@@ -36,7 +33,7 @@
   },
   "homepage": "https://github.com/zOadT/concurrent-top-level-await-plugins/tree/main/packages/rolldown-plugin#readme",
   "peerDependencies": {
-    "rolldown": "^1.0.0-rc.0",
+    "rolldown": "^1.0.0 || ^1.0.0-rc.0",
     "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {
@@ -54,12 +51,12 @@
       "reason": "Uses Rolldown-specific APIs"
     }
   },
-  "dependencies": {
-    "@rolldown/pluginutils": "1.0.0-rc.9"
-  },
   "devDependencies": {
     "@types/estree": "^1.0.8",
     "prettier": "3.7.4",
     "rolldown": "1.0.0-rc.9"
+  },
+  "scripts": {
+    "build": "tsdown --dts"
   }
-}
+}