toPromise(actorRef)

packages/core/src/index.ts

@@ -33,7 +33,7 @@ export type {
   InspectionEvent,
   ActorSystem
 } from './system.ts';
-
+export { toPromise } from './toPromise.ts';
 export { and, not, or, stateIn } from './guards.ts';
 export { setup } from './setup.ts';
 

packages/core/src/toPromise.ts

@@ -0,0 +1,43 @@
+import { Actor, AnyActorRef, OutputFrom } from '.';
+
+/**
+ * Returns a promise that resolves to the `output` of the actor when it is done.
+ *
+ * @example
+ * ```ts
+ * const machine = createMachine({
+ *   // ...
+ *   output: {
+ *     count: 42
+ *   }
+ * });
+ *
+ * const actor = createActor(machine);
+ *
+ * actor.start();
+ *
+ * const output = await toPromise(actor);
+ *
+ * console.log(output);
+ * // logs { count: 42 }
+ * ```
+ */
+export function toPromise<T extends AnyActorRef>(
+  actor: T
+): Promise<T extends Actor<infer TLogic> ? OutputFrom<TLogic> : unknown> {
+  return new Promise((resolve, reject) => {
+    actor.subscribe({
+      complete: () => {
+        resolve(
+          actor.getSnapshot().output
+          // actor.getOutput()! as T extends Actor<infer TLogic>
+          //   ? OutputFrom<TLogic>
+          //   : unknown
+        );
+      },
+      error: (err) => {
+        reject(err);
+      }
+    });
+  });
+}

packages/core/test/toPromise.test.ts

@@ -0,0 +1,70 @@
+import { createActor, createMachine, fromPromise, toPromise } from '../src';
+
+describe('toPromise', () => {
+  it('should be awaitable', async () => {
+    const promiseActor = createActor(
+      fromPromise(() => Promise.resolve(42))
+    ).start();
+
+    const result = await toPromise(promiseActor);
+
+    result satisfies number;
+
+    expect(result).toEqual(42);
+  });
+
+  it('should await actors', async () => {
+    const machine = createMachine({
+      types: {} as {
+        output: { count: 42 };
+      },
+      initial: 'pending',
+      states: {
+        pending: {
+          on: {
+            RESOLVE: 'done'
+          }
+        },
+        done: {
+          type: 'final'
+        }
+      },
+      output: { count: 42 }
+    });
+
+    const actor = createActor(machine).start();
+
+    setTimeout(() => {
+      actor.send({ type: 'RESOLVE' });
+    }, 1);
+
+    const data = await toPromise(actor);
+
+    data satisfies { count: number };
+
+    expect(data).toEqual({ count: 42 });
+  });
+
+  it('should await already done actors', async () => {
+    const machine = createMachine({
+      types: {} as {
+        output: { count: 42 };
+      },
+      initial: 'done',
+      states: {
+        done: {
+          type: 'final'
+        }
+      },
+      output: { count: 42 }
+    });
+
+    const actor = createActor(machine).start();
+
+    const data = await toPromise(actor);
+
+    data satisfies { count: number };
+
+    expect(data).toEqual({ count: 42 });
+  });
+});