@alloy-js/core 0.19.0-dev.2 → 0.19.0

package/src/scheduler.ts

@@ -5,6 +5,7 @@ export interface QueueJob {
 }
 const immediateQueue = new Set<QueueJob>();
 const queue = new Set<QueueJob>();
+const pendingPromises = new Set<Promise<any>>();
 
 export function scheduler(
   jobGetter: () => ReactiveEffectRunner,
@@ -25,11 +26,49 @@ export function queueJob(job: QueueJob, immediate = false) {
   }
 }
 
+/**
+ * Register a promise that the scheduler should wait for during flushJobs.
+ * This is used by async resources to ensure the scheduler waits for their completion.
+ */
+export function trackPromise(promise: Promise<any>) {
+  pendingPromises.add(promise);
+  void promise.finally(() => {
+    pendingPromises.delete(promise);
+  });
+}
+
 export function flushJobs() {
+  // First, run all synchronous jobs
   let job;
   while ((job = takeJob()) !== null) {
     job();
   }
+
+  // If there are no pending promises, we're done
+  if (pendingPromises.size > 0) {
+    throw new Error(
+      "Asynchronous jobs were found but render was called synchronously. Use `asyncRender` instead.",
+    );
+  }
+}
+
+export async function flushJobsAsync() {
+  // Keep running jobs until both the queues are empty and all promises are resolved
+  while (true) {
+    // First, run all synchronous jobs
+    let job;
+    while ((job = takeJob()) !== null) {
+      job();
+    }
+
+    // If there are no pending promises, we're done
+    if (pendingPromises.size === 0) {
+      break;
+    }
+
+    // Wait for all current promises to complete
+    await Promise.allSettled(Array.from(pendingPromises));
+  }
 }
 
 function takeJob() {

package/src/write-output.ts

@@ -1,33 +1,63 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { relative, resolve } from "pathe";
+import { dirname, relative, resolve } from "pathe";
+import { AlloyHost } from "./host/alloy-host.js";
 import { OutputDirectory } from "./render.js";
 import { traverseOutput } from "./utils.js";
 /**
  * Write the output from {@link render} to the file system.
  *
  */
-export function writeOutput(output: OutputDirectory, basePath: string = "") {
+export async function writeOutput(
+  output: OutputDirectory,
+  basePath: string = "",
+) {
+  const ops: Promise<void>[] = [];
+
   traverseOutput(output, {
     visitDirectory(directory) {
-      const path = resolve(basePath, directory.path);
-      if (existsSync(path)) {
-        return;
-      }
-      // eslint-disable-next-line no-console
-      console.log("create", relative(process.cwd(), path));
-      mkdirSync(path, { recursive: true });
+      ops.push(
+        (async () => {
+          const path = resolve(basePath, directory.path);
+          if (await AlloyHost.exists(path)) {
+            return;
+          }
+          // eslint-disable-next-line no-console
+          console.log("create", relative(process.cwd(), path));
+          await AlloyHost.mkdir(path);
+        })(),
+      );
     },
     visitFile(file) {
-      const path = resolve(basePath, file.path);
-      if (existsSync(path)) {
-        // eslint-disable-next-line no-console
-        console.log("overwrite", relative(process.cwd(), path));
-      } else {
-        // eslint-disable-next-line no-console
-        console.log("create", relative(process.cwd(), path));
-      }
+      ops.push(
+        (async () => {
+          if ("contents" in file) {
+            const path = resolve(basePath, file.path);
+            if (await AlloyHost.exists(path)) {
+              // eslint-disable-next-line no-console
+              console.log("overwrite", relative(process.cwd(), path));
+            } else {
+              // eslint-disable-next-line no-console
+              console.log("create", relative(process.cwd(), path));
+            }
 
-      writeFileSync(path, file.contents);
+            await AlloyHost.write(path, file.contents);
+          } else {
+            // copy file
+            const source = resolve(basePath, file.sourcePath);
+            const target = resolve(basePath, file.path);
+            if (await AlloyHost.exists(target)) {
+              // eslint-disable-next-line no-console
+              console.log("copy over", relative(process.cwd(), target));
+            } else {
+              // eslint-disable-next-line no-console
+              console.log("copy", relative(process.cwd(), target));
+            }
+            await AlloyHost.mkdir(dirname(target));
+            await AlloyHost.write(target, AlloyHost.read(source).stream());
+          }
+        })(),
+      );
     },
   });
+
+  return Promise.all(ops);
 }