Add accumulations

Author: RoyalIcing

src/index.test.ts

@@ -12,6 +12,7 @@ import {
   listenTo,
   send,
   start,
+  accumulate,
 } from "./index";
 
 test("node version " + process.version, () => {});
@@ -615,6 +616,54 @@ describe("Button click", () => {
   });
 });
 
+describe("accumulate", () => {
+  const messagesKey = Symbol("messages");
+
+  function* Machine(eventTarget: EventTarget) {
+    // yield on(new Map([["type", "error"], ["readyState", EventSource.CLOSED]]), Closed);
+    yield on("error", Closed);
+
+    function* Open() {
+      yield listenTo(eventTarget, "message");
+      yield accumulate("message", messagesKey);
+    }
+    function* Closed() {}
+    
+    return function* Connecting() {
+      yield listenTo(eventTarget, "open");
+      yield on("open", Open);
+    }
+  }
+
+  it("works", () => {
+    // const eventTarget = new AbortSignal();
+    const eventTarget = (new AbortController()).signal;
+    const machine = start(Machine.bind(null, eventTarget));
+
+    expect(machine.current).toEqual("Connecting");
+    
+    eventTarget.dispatchEvent(new Event("open"));
+    expect(machine.current).toEqual("Open");
+    expect(machine.accumulations).toEqual(new Map());
+
+    const event1 = new Event("message");
+    const event2 = new Event("message");
+    const event3 = new Event("message");
+
+    eventTarget.dispatchEvent(event1);
+    expect(machine.current).toEqual("Open");
+    expect(machine.accumulations).toEqual(new Map([[messagesKey, [event1]]]));
+
+    eventTarget.dispatchEvent(event2);
+    expect(machine.current).toEqual("Open");
+    expect(machine.accumulations).toEqual(new Map([[messagesKey, [event1, event2]]]));
+
+    eventTarget.dispatchEvent(event3);
+    expect(machine.current).toEqual("Open");
+    expect(machine.accumulations).toEqual(new Map([[messagesKey, [event1, event2, event3]]]));
+  })
+});
+
 /*describe("Counter", () => {
   function* Counter() {
     function* initial() {

src/index.ts

@@ -54,7 +54,13 @@ export interface Send<Method extends string | symbol, Arguments extends any[]> {
   args: Arguments;
 }
 
-export type Yielded = On | Always | Cond | EntryAction | ExitAction | ListenTo | Call<any>;
+export interface Accumulate {
+  type: "accumulate";
+  eventName: string | symbol;
+  resultKey: symbol;
+}
+
+export type Yielded = On | Always | Cond | EntryAction | ExitAction | ListenTo | Accumulate | Call<any>;
 
 export function on<Event extends string | symbol>(event: Event, target: Target): On {
   return { type: "on", on: event, target };
@@ -99,10 +105,15 @@ export function compound(...targets: Array<StateDefinition>): Compound {
   return { type: "compound", targets };
 }
 
+export function accumulate(eventName: string | symbol, resultKey: symbol): Accumulate {
+  return { type: "accumulate", eventName, resultKey };
+}
+
 export interface MachineInstance extends Iterator<null | string | Record<string, string>, void, string | symbol> {
   changeCount: number;
   current: null | string | Record<string, string>;
   results: null | Promise<unknown>;
+  accumulations: Map<symbol | string, Array<symbol | string | Event>>;
   done: boolean;
   next(arg: string | symbol): IteratorResult<null | string | Record<string, string>> &
     PromiseLike<any> & {
@@ -120,6 +131,7 @@ class Handlers {
   private actionResults = new Map<string | symbol, unknown>();
   private promise: null | Promise<Array<unknown>> = null;
   public readonly eventsToListenTo = new Array<[string, EventTarget]>();
+  public readonly eventsToAccumulate = new Array<[string | symbol, symbol]>();
 
   *actions(): Generator<EntryAction, void, undefined> {
     yield* this.entryActions;
@@ -171,6 +183,8 @@ class Handlers {
       this.alwaysArray.push(value);
     } else if (value.type === 'listenTo') {
       this.eventsToListenTo.push([value.eventName, value.sender]);
+    } else if (value.type === 'accumulate') {
+      this.eventsToAccumulate.push([value.eventName, value.resultKey]);
     }
   }
 
@@ -207,6 +221,7 @@ class InternalInstance {
   private parent: null | InternalInstance
   private globalHandlers = new Handlers()
   private resolved = null as Promise<Record<string, any>> | null
+  private accumulations: Map<symbol | string, Array<symbol | string | Event>> = new Map();
   private eventAborter = new AbortController();
   child: null | InternalInstance = null
 
@@ -266,8 +281,19 @@ class InternalInstance {
     // return build().then(pairs => Object.fromEntries(pairs as any));
   }
 
+  *allAccumulations(): Generator<[symbol | string, Array<string | symbol | Event>]> /*: Generator<{ key: symbol | string, events: Array<string | symbol | Event> }>*/ {
+    for (const [key, events] of this.accumulations) {
+      // yield { key, events };
+      yield [key, events];
+    }
+
+    if (this.child !== null) {
+      yield *this.child.allAccumulations();
+    }
+  }
+
   handleEvent(event: Event) {
-    this.receive(event.type);
+    this.receive(event);
   }
 
   cleanup() {
@@ -393,13 +419,23 @@ class InternalInstance {
     return false;
   }
 
-  receive(event: string | symbol) {
+  receive(event: string | symbol | Event) {
     this.child?.receive(event);
 
-    const target = this.globalHandlers.targetForEvent(event);
+    const eventName = typeof event === 'string' || typeof event === 'symbol' ? event : event.type;
+
+    const target = this.globalHandlers.targetForEvent(eventName);
     if (target !== undefined) {
       this.processTarget(target);
     }
+
+    for (const [iteratedEventName, resultKey] of this.globalHandlers.eventsToAccumulate) {
+      if (iteratedEventName === eventName) {
+        const current = this.accumulations.get(resultKey) ?? [];
+        console.log("accumulating event", eventName);
+        this.accumulations.set(resultKey, current.concat(event));
+      }
+    }
   }
 }
 
@@ -436,6 +472,9 @@ export function start(
     get results() {
       return instance.results;
     },
+    get accumulations() {
+      return new Map(instance.allAccumulations());
+    },
     next(event: string | symbol) {
       instance.receive(event);
       const promise = instance.results;