Add exit actions

Author: royalicing

src/index.test.ts

@@ -1,15 +1,19 @@
-import { call, entry, on, start } from "./index";
+import { call, entry, exit, on, start } from "./index";
 
 const fetch = jest.fn();
 beforeEach(fetch.mockClear);
 
+const finishedLoading = jest.fn();
+beforeEach(finishedLoading.mockClear);
+
 describe("Machine with entry", () => {
   function Loader() {
     function* idle() {
       yield on("FETCH", loading);
     }
     function* loading() {
       yield entry(fetchData);
+      yield exit(finishedLoading);
       yield on("SUCCESS", success);
       yield on("FAILURE", failure);
     }
@@ -47,16 +51,21 @@ describe("Machine with entry", () => {
 
       const transitionResult = loader.next("FETCH");
       expect(fetch).toHaveBeenCalledWith("https://example.org/");
-      expect(transitionResult.actions).toEqual([{ type: "entry", f: fetchData }]);
+      expect(transitionResult.actions).toEqual([
+        { type: "entry", f: fetchData },
+      ]);
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(1);
+      expect(finishedLoading).toHaveBeenCalledTimes(0);
 
       await expect(loader.resolved).resolves.toEqual([42]);
       await expect(Promise.resolve(transitionResult)).resolves.toEqual([42]);
+      expect(finishedLoading).toHaveBeenCalledTimes(1);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
-      
-      loader.next("FETCH");
+
+      const transitionResult2 = loader.next("FETCH");
+      expect(transitionResult2.actions).toEqual([]);
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("success");
 
@@ -73,25 +82,26 @@ describe("Machine with entry", () => {
       const loader = start(Loader, [{ url: someURL }]);
       expect(loader.value).toEqual("idle");
 
-      const { actions } = loader.next("FETCH");
+      const transitionResult = loader.next("FETCH");
       expect(fetch).toHaveBeenCalledTimes(1);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
-      expect(actions).toEqual([{ type: "entry", f: fetchData }]);
+      expect(transitionResult.actions).toEqual([{ type: "entry", f: fetchData }]);
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(1);
 
       await expect(loader.resolved).rejects.toEqual(new Error("Failed!"));
+      await expect(Promise.resolve(transitionResult)).rejects.toEqual(new Error("Failed!"));
       expect(loader.changeCount).toEqual(2);
       expect(loader.value).toEqual("failure");
 
       loader.next("FETCH");
       expect(fetch).toHaveBeenCalledTimes(1);
       expect(loader.changeCount).toEqual(2);
-      
+
       loader.next("RETRY");
       expect(loader.value).toEqual("loading");
       expect(loader.changeCount).toEqual(3);
-      
+
       expect(fetch).toHaveBeenCalledTimes(2);
       expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
 

src/index.ts

@@ -23,7 +23,7 @@ export interface On {
   target: Function;
 }
 
-export type Yielded = EntryAction | On | Call<any>;
+export type Yielded = On | EntryAction | ExitAction | Call<any>;
 
 export function call<Arguments extends Array<any>>(
   f: (...args: Arguments) => void,
@@ -51,9 +51,10 @@ export interface MachineInstance extends Iterator<string, void, string> {
   done: boolean;
   next(
     ...args: [string]
-  ): IteratorResult<string, void> & PromiseLike<any> & {
-    actions: Array<EntryAction | ExitAction>;
-  };
+  ): IteratorResult<string, void> &
+    PromiseLike<any> & {
+      actions: Array<EntryAction | ExitAction>;
+    };
 }
 
 export function start<Arguments extends Array<any>>(
@@ -67,7 +68,8 @@ export function start<Arguments extends Array<any>>(
   let state = {
     changeCount: -1,
     current: "",
-    actions: [] as Array<EntryAction | ExitAction>,
+    entryActions: [] as Array<EntryAction>,
+    exitActions: [] as Array<ExitAction>,
     resolved: null as Promise<Array<any>> | null,
   };
 
@@ -81,8 +83,14 @@ export function start<Arguments extends Array<any>>(
   }
 
   function transitionTo(stateGenerator: () => Generator<Yielded>) {
+    state.exitActions.forEach((action) => {
+      action.f();
+    });
+
     state.changeCount++;
     state.current = stateGenerator.name;
+    state.entryActions.splice(0, Infinity);
+    state.exitActions.splice(0, Infinity);
     state.resolved = null;
     eventsMap.clear();
 
@@ -91,12 +99,14 @@ export function start<Arguments extends Array<any>>(
     const iterable = stateGenerator();
     for (const value of iterable) {
       if (value.type === "entry") {
-        state.actions.push(value);
+        state.entryActions.push(value);
         // const result = Promise.resolve(value);
         const result = new Promise((resolve) => {
           resolve(value.f());
         });
         results.push(result);
+      } else if (value.type === "exit") {
+        state.exitActions.push(value);
       } else if (value.type === "call") {
         const result = new Promise((resolve) =>
           resolve(value.f.apply(null, value.args))
@@ -134,10 +144,10 @@ export function start<Arguments extends Array<any>>(
     next(event: string) {
       receive(event, state.changeCount);
       const promise = state.resolved!;
-      Promise.resolve
+      Promise.resolve;
       return {
         value: state.current,
-        actions: Array.from(state.actions),
+        actions: Array.from(state.entryActions),
         then: promise.then.bind(promise),
         done: false,
       };