Add always() and cond()

Author: royalicing

src/index.test.ts

@@ -1,4 +1,4 @@
-import { call, entry, exit, on, start } from "./index";
+import { always, call, cond, entry, exit, on, start } from "./index";
 
 const fetch = jest.fn();
 beforeEach(fetch.mockClear);
@@ -7,6 +7,11 @@ const finishedLoading = jest.fn();
 beforeEach(finishedLoading.mockClear);
 
 describe("Machine with entry and exit actions", () => {
+  const someURL = new URL("https://example.org/");
+  function fetchData() {
+    return fetch(someURL.toString());
+  }
+
   function Loader() {
     function* idle() {
       yield on("FETCH", loading);
@@ -25,11 +30,6 @@ describe("Machine with entry and exit actions", () => {
     return idle;
   }
 
-  const someURL = new URL("https://example.org/");
-  function fetchData() {
-    return fetch(someURL.toString());
-  }
-
   test("creating", () => {
     const loader = start(Loader);
     expect(loader).toBeDefined();
@@ -85,12 +85,16 @@ describe("Machine with entry and exit actions", () => {
       const transitionResult = loader.next("FETCH");
       expect(fetch).toHaveBeenCalledTimes(1);
       expect(fetch).toHaveBeenLastCalledWith("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);
 
       await expect(loader.resolved).rejects.toEqual(new Error("Failed!"));
-      await expect(Promise.resolve(transitionResult)).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");
 
@@ -112,6 +116,92 @@ describe("Machine with entry and exit actions", () => {
   });
 });
 
+describe("Form Field Machine with entry and exit actions", () => {
+  // const validate = jest.fn();
+  // beforeEach(validate.mockClear);
+  const isValid = jest.fn();
+  beforeEach(isValid.mockClear);
+
+  function FormField() {
+    function* initial() {
+      yield on("CHANGE", editing);
+    }
+    function* editing() {
+      // yield exit(validate);
+      yield on("CHANGE", editing);
+      yield on("BLUR", validating);
+    }
+    function* validating() {
+      yield always(cond(isValid, valid));
+      yield always(invalid);
+
+      // yield on(null, cond(isValid, valid));
+      // yield on(null, invalid);
+
+      // yield always([cond(isValid, valid), invalid]);
+      // return [cond(isValid, valid), invalid];
+      // return conds([[isValid, valid], [true, invalid]]);
+    }
+    function* invalid() {}
+    function* valid() {}
+
+    return initial;
+  }
+
+  test("creating", () => {
+    const formField = start(FormField);
+    expect(formField).toBeDefined();
+  });
+
+  describe("when is valid", () => {
+    beforeEach(() => {
+      isValid.mockReturnValue(true);
+    });
+
+    test("sending events", () => {
+      const formField = start(FormField);
+      expect(formField).toBeDefined();
+      expect(formField.value).toEqual("initial");
+
+      formField.next("CHANGE");
+      expect(formField.value).toEqual("editing");
+      expect(formField.changeCount).toEqual(1);
+
+      formField.next("CHANGE");
+      expect(formField.value).toEqual("editing");
+      expect(formField.changeCount).toEqual(2);
+
+      formField.next("BLUR");
+      expect(formField.value).toEqual("valid");
+      expect(formField.changeCount).toEqual(4);
+    });
+  });
+
+  describe("when is invalid", () => {
+    beforeEach(() => {
+      isValid.mockReturnValue(false);
+    });
+
+    test("sending events", () => {
+      const formField = start(FormField);
+      expect(formField).toBeDefined();
+      expect(formField.value).toEqual("initial");
+
+      formField.next("CHANGE");
+      expect(formField.value).toEqual("editing");
+      expect(formField.changeCount).toEqual(1);
+
+      formField.next("CHANGE");
+      expect(formField.value).toEqual("editing");
+      expect(formField.changeCount).toEqual(2);
+
+      formField.next("BLUR");
+      expect(formField.value).toEqual("invalid");
+      expect(formField.changeCount).toEqual(4);
+    });
+  });
+});
+
 describe("Machine with call", () => {
   function Loader({ url }: { url: URL }) {
     function* idle() {

src/index.ts

@@ -17,13 +17,24 @@ export interface ExitAction {
   f: ActionBody;
 }
 
+export type StateDefinition = () => Generator<Yielded, any, unknown>;
+export interface Cond {
+  type: "cond";
+  cond: Function;
+  target: StateDefinition;
+}
+export type Target = StateDefinition | Cond;
 export interface On {
   type: "on";
   on: string;
-  target: Function;
+  target: Target;
+}
+export interface Always {
+  type: "always";
+  target: Target;
 }
 
-export type Yielded = On | EntryAction | ExitAction | Call<any>;
+export type Yielded = On | Always | EntryAction | ExitAction | Call<any>;
 
 export function call<Arguments extends Array<any>>(
   f: (...args: Arguments) => void,
@@ -40,10 +51,18 @@ export function exit(f: ActionBody): ExitAction {
   return { type: "exit", f };
 }
 
-export function on<Event extends string>(event: Event, target: Function): On {
+export function on<Event extends string>(event: Event, target: Target): On {
   return { type: "on", on: event, target };
 }
 
+export function always(target: Target): Always {
+  return { type: "always", target };
+}
+
+export function cond(cond: () => boolean, target: StateDefinition): Cond {
+  return { type: "cond", cond, target };
+}
+
 export interface MachineInstance extends Iterator<string, void, string> {
   changeCount: number;
   value: string;
@@ -63,7 +82,8 @@ export function start<Arguments extends Array<any>>(
 ): MachineInstance {
   const initialGenerator = machine.apply(null, args);
 
-  const eventsMap = new Map();
+  const eventsMap: Map<string, Target> = new Map();
+  const alwaysArray: Array<Target> = [];
 
   let state = {
     changeCount: -1,
@@ -73,12 +93,27 @@ export function start<Arguments extends Array<any>>(
     resolved: null as Promise<Array<any>> | null,
   };
 
+  function processTarget(target: Target): boolean {
+    if ('type' in target) {
+      const result = target.cond();
+      if (result) {
+        transitionTo(target.target);
+        return true;
+      }
+    } else {
+      transitionTo(target);
+      return true;
+    }
+
+    return false;
+  }
+
   function receive(event: string, count: number) {
     if (count !== state.changeCount) return;
 
     const target = eventsMap.get(event);
     if (target) {
-      transitionTo(target);
+      processTarget(target);
     }
   }
 
@@ -93,6 +128,7 @@ export function start<Arguments extends Array<any>>(
     state.exitActions.splice(0, Infinity);
     state.resolved = null;
     eventsMap.clear();
+    alwaysArray.splice(0, Infinity);
 
     const results: Array<any> = [];
 
@@ -114,6 +150,8 @@ export function start<Arguments extends Array<any>>(
         results.push(result);
       } else if (value.type === "on") {
         eventsMap.set(value.on, value.target);
+      } else if (value.type === "always") {
+        alwaysArray.push(value.target);
       }
     }
 
@@ -127,6 +165,8 @@ export function start<Arguments extends Array<any>>(
     promise
       .then(() => receive("SUCCESS", snapshotCount))
       .catch(() => receive("FAILURE", snapshotCount));
+    
+    alwaysArray.some(processTarget);
   }
 
   transitionTo(initialGenerator);