rollup-plugin-concurrent-top-level-await 0.0.1 → 0.0.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-concurrent-top-level-await",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Rollup (and Vite) plugin enabling concurrent execution of modules that contain top level await.",
   "keywords": [
     "rollup-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"
@@ -50,5 +47,8 @@
   "devDependencies": {
     "@types/estree": "^1.0.8",
     "prettier": "3.7.4"
+  },
+  "scripts": {
+    "build": "tsdown --dts"
   }
-}
+}

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -1,242 +0,0 @@
-import { createFilter } from "@rollup/pluginutils";
-import MagicString from "magic-string";
-
-//#region src/hasTopLevelAwait.ts
-function hasTopLevelAwait(ast) {
-	let found = false;
-	function isFunctionNode(node) {
-		if (!node || typeof node.type !== "string") return false;
-		return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassPrivateMethod" || node.type === "MethodDefinition";
-	}
-	function walk(node, functionDepth = 0) {
-		if (!node || found) return;
-		if (node.type === "AwaitExpression" && functionDepth === 0) {
-			found = true;
-			return;
-		}
-		const nextDepth = functionDepth + (isFunctionNode(node) ? 1 : 0);
-		for (const key of Object.keys(node)) {
-			const child = node[key];
-			if (Array.isArray(child)) for (const c of child) walk(c, nextDepth);
-			else if (child && typeof child.type === "string") walk(child, nextDepth);
-		}
-	}
-	walk(ast, 0);
-	return found;
-}
-
-//#endregion
-//#region src/polyfills/promise.ts
-function withResolvers() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-
-//#endregion
-//#region src/AsyncTlaTracker.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];
-	}
-	set(key, value) {
-		const [_, resolve] = this.#getPromise(key);
-		resolve(value);
-	}
-	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);
-	}
-	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);
-	}
-	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);
-			});
-		});
-		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);
-	}
-};
-
-//#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 tansformAndMoveDeclarationsToModuleScope(s, ast, asyncImports) {
-	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);
-			i++;
-		}
-		if (node.type === "ExportNamedDeclaration") {
-			if (node.declaration?.type === "VariableDeclaration") {
-				s = s.appendLeft(moduleScopeEnd, ";export ");
-				s = s.remove(node.start, node.declaration.start);
-				s = moveVarDeclarationToModuleScope(s, node.declaration, moduleScopeEnd);
-			}
-		}
-		if (node.type === "VariableDeclaration") s = moveVarDeclarationToModuleScope(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);
-		} else moduleScopeEnd = node.end;
-	}
-	return [s, moduleScopeEnd];
-}
-function isDeclaration(type) {
-	return type === "ClassDeclaration" || type === "FunctionDeclaration";
-}
-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.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 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/index.ts
-function concurrentTopLevelAwait(options = {}) {
-	const filter = createFilter(options.include, options.exclude);
-	const asyncTree = new AsyncTlaTracker();
-	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 importDeclarations = ast.body.filter((a) => a.type === "ImportDeclaration");
-			const hasAwait = hasTopLevelAwait(ast);
-			if (hasAwait) asyncTree.setMarked(id, true);
-			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);
-			}
-			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;
-				return declaration;
-			}))).filter(Boolean);
-			const isAsyncModule = asyncImports.length > 0 || hasAwait;
-			if (!isAsyncModule) return;
-			let s = new MagicString(code);
-			s = transform(s, ast, asyncImports, hasAwait);
-			return {
-				code: s.toString(),
-				meta: { async: isAsyncModule }
-			};
-		} },
-		resolveImportMeta(property, { moduleId, chunkId }) {
-			if (property !== "useTla") return;
-			const moduleInfo = this.getModuleInfo(moduleId);
-			const importers = moduleInfo?.importers;
-			if (moduleInfo?.isEntry || !importers?.length) return "true";
-			if (importers.some((id) => !filter(id))) return "true";
-			return "false";
-		}
-	};
-}
-
-//#endregion
-export { concurrentTopLevelAwait as default };