Support symbol messages

Author: RoyalIcing

src/index.test.ts

@@ -123,6 +123,130 @@ describe("Machine with entry and exit actions", () => {
   });
 });
 
+describe.skip("Fetch with abort signal", () => {
+  const someURL = new URL("https://example.org/");
+  function fetchData() {
+    return fetch(someURL.toString());
+  }
+
+  function Loader() {
+    const aborterKey = Symbol('aborter');
+    // yield register(aborterKey, () => new AbortController());
+    // yield register(function aborter() { return new AbortController() });
+
+    function* idle() {
+      yield on("FETCH", loading);
+    }
+    function* loading() {
+      // yield entry(aborterKey);
+
+      yield entry(fetchData);
+      yield exit(finishedLoading);
+      yield on("SUCCESS", success);
+      yield on("FAILURE", failure);
+      // yield forward(AbortController.prototype.abort, aborter);
+      // yield forward("abort", aborter);
+      // yield forward("CANCEL", aborter);
+      // yield forward("CANCEL", aborterKey);
+    }
+    function* success() {
+      yield entry(succeeded);
+    }
+    function* failure() {
+      yield on("RETRY", loading);
+    }
+
+    return idle;
+  }
+
+  test("creating", () => {
+    const loader = start(Loader);
+    expect(loader).toBeDefined();
+  });
+
+  describe("when fetch succeeds", () => {
+    beforeEach(() => {
+      fetch.mockResolvedValue(42);
+    });
+
+    test("sending events", async () => {
+      const loader = start(Loader);
+      expect(loader.current).toEqual("idle");
+      expect(loader.changeCount).toEqual(0);
+
+      loader.next("NOOP");
+      expect(loader.current).toEqual("idle");
+      expect(loader.changeCount).toEqual(0);
+
+      const transitionResult = loader.next("FETCH");
+      expect(fetch).toHaveBeenCalledWith("https://example.org/");
+      expect(transitionResult.actions).toEqual([
+        { type: "entry", f: fetchData },
+      ]);
+      expect(loader.current).toEqual("loading");
+      expect(loader.changeCount).toEqual(1);
+      expect(finishedLoading).toHaveBeenCalledTimes(0);
+
+      await expect(loader.results).resolves.toEqual({ fetchData: 42 });
+      await expect(Promise.resolve(transitionResult)).resolves.toEqual({ fetchData: 42 });
+      expect(finishedLoading).toHaveBeenCalledTimes(1);
+      expect(loader.changeCount).toEqual(2);
+      expect(loader.current).toEqual("success");
+      expect(succeeded).toHaveBeenCalledTimes(1);
+
+      const transitionResult2 = loader.next("FETCH");
+      // expect(transitionResult2.actions).toEqual([]);
+      expect(loader.changeCount).toEqual(2);
+      expect(loader.current).toEqual("success");
+      expect(succeeded).toHaveBeenCalledTimes(1);
+
+      await loader.results;
+    });
+  });
+
+  describe("when fetch fails", () => {
+    beforeEach(() => {
+      fetch.mockRejectedValueOnce(new Error("Failed!")).mockResolvedValue(42);
+    });
+
+    test("sending events", async () => {
+      const loader = start(Loader);
+      expect(loader.current).toEqual("idle");
+
+      const transitionResult = loader.next("FETCH");
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
+      expect(transitionResult.actions).toEqual([
+        { type: "entry", f: fetchData },
+      ]);
+      expect(loader.current).toEqual("loading");
+      expect(loader.changeCount).toEqual(1);
+
+      await expect(loader.results).rejects.toEqual(new Error("Failed!"));
+      await expect(Promise.resolve(transitionResult)).rejects.toEqual(
+        new Error("Failed!")
+      );
+      expect(loader.changeCount).toEqual(2);
+      expect(loader.current).toEqual("failure");
+
+      loader.next("FETCH");
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(loader.changeCount).toEqual(2);
+
+      loader.next("RETRY");
+      expect(loader.current).toEqual("loading");
+      expect(loader.changeCount).toEqual(3);
+
+      expect(fetch).toHaveBeenCalledTimes(2);
+      expect(fetch).toHaveBeenLastCalledWith("https://example.org/");
+
+      await expect(loader.results).resolves.toEqual({ fetchData: 42 });
+      expect(loader.changeCount).toEqual(4);
+      expect(loader.current).toEqual("success");
+    });
+  });
+});
+
 describe("Form Field Machine with always()", () => {
   const isValid = jest.fn();
   beforeEach(isValid.mockClear);
@@ -294,6 +418,39 @@ describe("Switch", () => {
   });
 });
 
+describe("Switch with symbol messages", () => {
+  const FLICK = Symbol('FLICK');
+
+  function* Switch() {
+    function* OFF() {
+      yield on(FLICK, ON);
+    }
+    function* ON() {
+      yield on(FLICK, OFF);
+    }
+
+    return OFF;
+  }
+
+  test("sending events", () => {
+    const machine = start(Switch);
+    expect(machine).toBeDefined();
+    expect(machine.current).toEqual("OFF");
+
+    machine.next(FLICK);
+    expect(machine.current).toEqual("ON");
+    expect(machine.changeCount).toEqual(1);
+
+    machine.next(FLICK);
+    expect(machine.current).toEqual("OFF");
+    expect(machine.changeCount).toEqual(2);
+
+    machine.next(Symbol('will be ignored'));
+    expect(machine.current).toEqual("OFF");
+    expect(machine.changeCount).toEqual(2);
+  });
+});
+
 /*describe("Counter", () => {
   function* Counter() {
     function* initial() {

src/index.ts

@@ -30,7 +30,7 @@ export interface Compound {
 export type Target = StateDefinition | Cond | Compound;
 export interface On {
   type: "on";
-  on: string;
+  on: string | symbol;
   target: Target;
 }
 export interface Always {
@@ -55,7 +55,7 @@ export function exit(f: ActionBody): ExitAction {
   return { type: "exit", f };
 }
 
-export function on<Event extends string>(event: Event, target: Target): On {
+export function on<Event extends string | symbol>(event: Event, target: Target): On {
   return { type: "on", on: event, target };
 }
 
@@ -77,15 +77,15 @@ export interface MachineInstance extends Iterator<null | string | Record<string,
   results: null | Promise<Array<any>>;
   done: boolean;
   next(
-    ...args: [string]
+    ...args: [string | symbol]
   ): IteratorResult<null | string | Record<string, string>> &
     PromiseLike<any> & {
       actions: Array<EntryAction | ExitAction>;
     };
 }
 
 class Handlers {
-  private eventsMap = new Map<string, Target>();
+  private eventsMap = new Map<string | symbol, Target>();
   private alwaysArray = new Array<Target>();
   private entryActions = [] as Array<EntryAction>;
   private exitActions = [] as Array<ExitAction>;
@@ -147,7 +147,7 @@ class Handlers {
     this.alwaysArray.some(process);
   }
 
-  targetForEvent(event: string) {
+  targetForEvent(event: string | symbol) {
     return this.eventsMap.get(event);
   }
 }
@@ -324,7 +324,7 @@ class InternalInstance {
     return false;
   }
 
-  receive(event: string) {
+  receive(event: string | symbol) {
     this.child?.receive(event);
 
     const target = this.globalHandlers.targetForEvent(event);
@@ -367,7 +367,7 @@ export function start(
     get results() {
       return instance.results;
     },
-    next(event: string) {
+    next(event: string | symbol) {
       instance.receive(event);
       const promise = instance.results;
       return {