Those are not thenables

Author: royalicing

src/index.test.ts

@@ -45,21 +45,22 @@ describe("Machine with entry", () => {
       expect(loader.value).toEqual("idle");
       expect(loader.changeCount).toEqual(0);
 
-      const { actions } = loader.next("FETCH");
+      const transitionResult = loader.next("FETCH");
       expect(fetch).toHaveBeenCalledWith("https://example.org/");
-      expect(actions).toEqual([{ type: "entry", then: fetchData }]);
+      expect(transitionResult.actions).toEqual([{ type: "entry", f: fetchData }]);
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(1);
 
-      await expect(loader.promisedValue).resolves.toEqual([42]);
+      await expect(loader.resolved).resolves.toEqual([42]);
+      await expect(Promise.resolve(transitionResult)).resolves.toEqual([42]);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
 
       loader.next("FETCH");
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
 
-      await loader.promisedValue;
+      await loader.resolved;
     });
   });
 
@@ -75,11 +76,11 @@ describe("Machine with entry", () => {
       const { actions } = loader.next("FETCH");
       expect(fetch).toHaveBeenCalledTimes(1);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
-      expect(actions).toEqual([{ type: "entry", then: fetchData }]);
+      expect(actions).toEqual([{ type: "entry", f: fetchData }]);
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(1);
 
-      await expect(loader.promisedValue).rejects.toEqual(new Error("Failed!"));
+      await expect(loader.resolved).rejects.toEqual(new Error("Failed!"));
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("failure");
 
@@ -94,7 +95,7 @@ describe("Machine with entry", () => {
       expect(fetch).toHaveBeenCalledTimes(2);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
 
-      await expect(loader.promisedValue).resolves.toEqual([42]);
+      await expect(loader.resolved).resolves.toEqual([42]);
       expect(loader.changeCount).toEqual(4);
       expect(loader.value).toEqual("success");
     });
@@ -134,27 +135,27 @@ describe("Machine with call", () => {
     test("sending events", async () => {
       const loader = start(Loader, [{ url: someURL }]);
       expect(loader.value).toEqual("idle");
-      await expect(loader.promisedValue).resolves.toEqual([]);
+      await expect(loader.resolved).resolves.toEqual([]);
 
       loader.next("NOOP");
       expect(loader.value).toEqual("idle");
       expect(loader.changeCount).toEqual(0);
-      await expect(loader.promisedValue).resolves.toEqual([]);
+      await expect(loader.resolved).resolves.toEqual([]);
 
       loader.next("FETCH");
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(1);
 
       expect(fetch).toHaveBeenCalledWith("https://example.org/");
 
-      await expect(loader.promisedValue).resolves.toEqual([42]);
+      await expect(loader.resolved).resolves.toEqual([42]);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
 
       loader.next("FETCH");
       expect(loader.changeCount).toEqual(2);
 
-      await loader.promisedValue;
+      await loader.resolved;
     });
   });
 
@@ -174,7 +175,7 @@ describe("Machine with call", () => {
       expect(fetch).toHaveBeenCalledTimes(1);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
 
-      await expect(loader.promisedValue).rejects.toEqual(new Error("Failed!"));
+      await expect(loader.resolved).rejects.toEqual(new Error("Failed!"));
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("failure");
 
@@ -189,7 +190,7 @@ describe("Machine with call", () => {
       expect(fetch).toHaveBeenCalledTimes(2);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
 
-      await expect(loader.promisedValue).resolves.toEqual([42]);
+      await expect(loader.resolved).resolves.toEqual([42]);
       expect(loader.changeCount).toEqual(4);
       expect(loader.value).toEqual("success");
     });

src/index.ts

@@ -10,11 +10,11 @@ export interface ActionBody {
 
 export interface EntryAction {
   type: "entry";
-  then: ActionBody;
+  f: ActionBody;
 }
 export interface ExitAction {
   type: "exit";
-  then: ActionBody;
+  f: ActionBody;
 }
 
 export interface On {
@@ -32,12 +32,12 @@ export function call<Arguments extends Array<any>>(
   return { type: "call", f, args };
 }
 
-export function entry(then: ActionBody): EntryAction {
-  return { type: "entry", then };
+export function entry(f: ActionBody): EntryAction {
+  return { type: "entry", f };
 }
 
-export function exit(then: ActionBody): ExitAction {
-  return { type: "exit", then };
+export function exit(f: ActionBody): ExitAction {
+  return { type: "exit", f };
 }
 
 export function on<Event extends string>(event: Event, target: Function): On {
@@ -47,11 +47,11 @@ export function on<Event extends string>(event: Event, target: Function): On {
 export interface MachineInstance extends Iterator<string, void, string> {
   changeCount: number;
   value: string;
-  promisedValue: null | Promise<Array<any>>;
+  resolved: null | Promise<Array<any>>;
   done: boolean;
   next(
     ...args: [string]
-  ): IteratorResult<string, void> & {
+  ): IteratorResult<string, void> & PromiseLike<any> & {
     actions: Array<EntryAction | ExitAction>;
   };
 }
@@ -68,7 +68,7 @@ export function start<Arguments extends Array<any>>(
     changeCount: -1,
     current: "",
     actions: [] as Array<EntryAction | ExitAction>,
-    promisedValue: null as Promise<Array<any>> | null,
+    resolved: null as Promise<Array<any>> | null,
   };
 
   function receive(event: string, count: number) {
@@ -83,7 +83,7 @@ export function start<Arguments extends Array<any>>(
   function transitionTo(stateGenerator: () => Generator<Yielded>) {
     state.changeCount++;
     state.current = stateGenerator.name;
-    state.promisedValue = null;
+    state.resolved = null;
     eventsMap.clear();
 
     const results: Array<any> = [];
@@ -94,7 +94,7 @@ export function start<Arguments extends Array<any>>(
         state.actions.push(value);
         // const result = Promise.resolve(value);
         const result = new Promise((resolve) => {
-          resolve(value.then())
+          resolve(value.f());
         });
         results.push(result);
       } else if (value.type === "call") {
@@ -108,10 +108,10 @@ export function start<Arguments extends Array<any>>(
     }
 
     // const promise = Promise.all(results);
-    const promise = Promise.resolve(state.promisedValue)
+    const promise = Promise.resolve(state.resolved)
       .catch(() => {})
       .then(() => Promise.all(results));
-    state.promisedValue = promise;
+    state.resolved = promise;
 
     const snapshotCount = state.changeCount;
     promise
@@ -128,14 +128,17 @@ export function start<Arguments extends Array<any>>(
     get value() {
       return state.current;
     },
-    get promisedValue() {
-      return state.promisedValue;
+    get resolved() {
+      return state.resolved;
     },
     next(event: string) {
       receive(event, state.changeCount);
+      const promise = state.resolved!;
+      Promise.resolve
       return {
         value: state.current,
         actions: Array.from(state.actions),
+        then: promise.then.bind(promise),
         done: false,
       };
     },