[core] Modeling events with createModel()

packages/core/src/model.ts

@@ -6,24 +6,82 @@ import type {
   ExtractEvent,
   EventObject
 } from './types';
+import { mapValues } from './utils';
 
-export interface ContextModel<TContext, TEvent extends EventObject> {
+export interface ContextModel<
+  TContext,
+  TEvent extends EventObject,
+  TEM extends EventCreatorMap<TEvent> = EventCreatorMap<TEvent>
+> {
   initialContext: TContext;
   assign: <TEventType extends TEvent['type'] = TEvent['type']>(
     assigner:
       | Assigner<TContext, ExtractEvent<TEvent, TEventType>>
       | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>,
     eventType?: TEventType
   ) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+  events: FullEventCreatorMap<TEM>;
+  types: {
+    context: TContext;
+    events: TEvent;
+  };
   reset: () => AssignAction<TContext, any>;
 }
 
+type EventCreatorMap<TEvent extends EventObject> = {
+  [key in TEvent['type']]: (
+    ...args: any[]
+  ) => Omit<TEvent & { type: key }, 'type'>;
+};
+
+type FullEventCreatorMap<
+  TEM extends EventCreatorMap<any>,
+  TE extends EventObject = GetEvents<TEM>
+> = TEM extends any
+  ? {
+      [K in keyof TEM]: (
+        ...args: Parameters<TEM[K]>
+      ) => TE extends { type: K } ? TE : never;
+    }
+  : never;
+
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type Distribute<U, V extends Record<string, () => object>> = U extends keyof V &
+  string
+  ? Expand<{ type: U } & ReturnType<V[U]>>
+  : never;
+
+type GetEvents<T extends EventCreatorMap<any>> = Distribute<keyof T, T>;
+
 export function createModel<TContext, TEvent extends EventObject>(
   initialContext: TContext
-): ContextModel<TContext, TEvent> {
-  const model: ContextModel<TContext, TEvent> = {
+): ContextModel<TContext, TEvent, never>;
+export function createModel<
+  TContext,
+  TEM extends EventCreatorMap<any>,
+  TEvent extends EventObject = GetEvents<TEM>
+>(
+  initialContext: TContext,
+  eventCreators: TEM
+): ContextModel<TContext, TEvent, TEM>;
+export function createModel<
+  TContext,
+  TEM extends EventCreatorMap<any>,
+  TEvent extends EventObject = GetEvents<TEM>
+>(initialContext: TContext, eventCreators?) {
+  const model: ContextModel<TContext, TEvent, TEM> = {
     initialContext,
     assign,
+    events: (eventCreators
+      ? mapValues(
+          eventCreators,
+          (fn, eventType) => (...args: Parameters<typeof fn>) => ({
+            type: eventType,
+            ...fn(...args)
+          })
+        )
+      : undefined) as FullEventCreatorMap<TEM>,
+    types: {} as any,
     reset: () => assign(initialContext)
   };
 

packages/core/test/model.test.ts

@@ -130,4 +130,68 @@ describe('createModel', () => {
 
     expect(resetState.context).toEqual(userModel.initialContext);
   });
+
+  it('can model events', () => {
+    const userModel = createModel(
+      {
+        name: 'David',
+        age: 30
+      },
+      {
+        updateName: (value: string) => ({ value }),
+        updateAge: (value: number) => ({ value }),
+        anotherEvent: () => ({})
+      }
+    );
+
+    // Example of an externally-defined assign action
+    const assignName = userModel.assign(
+      {
+        name: (_, event) => {
+          return event.value;
+        }
+      },
+      'updateName'
+    );
+
+    const machine = createMachine<
+      typeof userModel['types']['context'],
+      typeof userModel['types']['events']
+    >({
+      context: userModel.initialContext,
+      initial: 'active',
+      states: {
+        active: {
+          on: {
+            updateName: {
+              // pre-defined assign action
+              actions: assignName
+            },
+            updateAge: {
+              // inline assign action
+              actions: userModel.assign((_, e) => {
+                return {
+                  age: e.value
+                };
+              })
+            }
+          }
+        }
+      }
+    });
+
+    let updatedState = machine.transition(
+      undefined,
+      userModel.events.updateName('Anyone')
+    );
+
+    expect(updatedState.context.name).toEqual('Anyone');
+
+    updatedState = machine.transition(
+      updatedState,
+      userModel.events.updateAge(42)
+    );
+
+    expect(updatedState.context.age).toEqual(42);
+  });
 });