Add trigger

Author: davidkpiano

packages/core/src/createActor.ts

@@ -132,6 +132,12 @@ export class Actor<TLogic extends AnyActorLogic>
   public system: AnyActorSystem;
   private _doneEvent?: DoneActorEvent;
 
+  public trigger: ActorRef<
+    SnapshotFrom<TLogic>,
+    EventFromLogic<TLogic>,
+    EmittedFrom<TLogic>
+  >['trigger'];
+
   public src: string | AnyActorLogic;
 
   /**
@@ -235,6 +241,20 @@ export class Actor<TLogic extends AnyActorLogic>
     // Ensure that the send method is bound to this Actor instance
     // if destructured
     this.send = this.send.bind(this);
+    this.trigger = new Proxy(
+      {} as ActorRef<
+        SnapshotFrom<TLogic>,
+        EventFromLogic<TLogic>,
+        EmittedFrom<TLogic>
+      >['trigger'],
+      {
+        get: (_, eventType: string) => {
+          return (payload?: any) => {
+            this.send({ ...payload, type: eventType });
+          };
+        }
+      }
+    );
 
     // unified '@xstate.transition' event replaces '@xstate.actor'
 

packages/core/src/createMachine.ts

@@ -85,7 +85,6 @@ export function createMachine<
   TOutputSchema extends StandardSchemaV1,
   TMetaSchema extends StandardSchemaV1,
   TTagSchema extends StandardSchemaV1,
-  // TContext extends MachineContext,
   _TEvent extends EventObject,
   TActor extends ProvidedActor,
   TActionMap extends Implementations['actions'],

packages/core/src/types.ts

@@ -65,6 +65,8 @@ export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
 
 export type IndexByType<T extends { type: string }> = IndexByProp<T, 'type'>;
 
+export type IsEmptyObject<T> = keyof T extends never ? true : false;
+
 export type Equals<A1, A2> =
   (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1
     ? true
@@ -1705,13 +1707,16 @@ export interface ActorRef<
       emitted: TEmitted & (TType extends '*' ? unknown : { type: TType })
     ) => void
   ) => Subscription;
+  trigger: {
+    [K in TEvent['type']]: IsEmptyObject<
+      Omit<Extract<TEvent, { type: K }>, 'type'>
+    > extends true
+      ? () => void
+      : (payload: Omit<Extract<TEvent, { type: K }>, 'type'>) => void;
+  };
 }
 
-export type AnyActorRef = ActorRef<
-  any,
-  AnyEventObject, // TODO: shouldn't this be AnyEventObject?
-  any
->;
+export type AnyActorRef = ActorRef<any, any, any>;
 
 export type ActorRefLike = Pick<
   AnyActorRef,

packages/core/test/actor.test.ts

@@ -211,8 +211,8 @@ describe('spawning machines', () => {
     });
     service.start();
 
-    service.send({ type: 'ADD', id: 42 });
-    service.send({ type: 'SET_COMPLETE', id: 42 });
+    service.trigger.ADD({ id: 42 });
+    service.trigger.SET_COMPLETE({ id: 42 });
     return promise;
   });
 
@@ -383,7 +383,11 @@ describe('spawning callbacks', () => {
           callbackRef: z
             .custom<CallbackActorRef<{ type: 'START' }>>()
             .optional()
-        })
+        }),
+        events: {
+          START_CB: z.object({}),
+          SEND_BACK: z.object({})
+        }
       },
       id: 'callback',
       initial: 'idle',
@@ -435,7 +439,7 @@ describe('spawning callbacks', () => {
     });
 
     callbackService.start();
-    callbackService.send({ type: 'START_CB' });
+    callbackService.trigger.START_CB();
     return promise;
   });
 
@@ -918,6 +922,7 @@ describe('communicating with spawned actors', () => {
           existingRef: z.custom<typeof existingService>().optional()
         }),
         events: {
+          // TODO: this causes parentMachine to be any
           ACTIVATE: z.object({ origin: z.custom<typeof parentService>() }),
           'EXISTING.DONE': z.object({})
         }

packages/core/test/trigger.test.ts

@@ -0,0 +1,126 @@
+import { createMachine, createActor } from '../src/index.ts';
+import { z } from 'zod';
+
+describe('actor.trigger', () => {
+  it('should send events via trigger', () => {
+    const machine = createMachine({
+      initial: 'idle',
+      states: {
+        idle: {
+          on: {
+            NEXT: 'active'
+          }
+        },
+        active: {}
+      }
+    });
+
+    const actor = createActor(machine).start();
+
+    expect(actor.getSnapshot().value).toBe('idle');
+
+    actor.trigger.NEXT();
+
+    expect(actor.getSnapshot().value).toBe('active');
+  });
+
+  it('should send events with payload via trigger', () => {
+    const machine = createMachine({
+      schemas: {
+        context: z.object({ count: z.number() }),
+        events: {
+          INC: z.object({ by: z.number() })
+        }
+      },
+      context: { count: 0 },
+      initial: 'idle',
+      states: {
+        idle: {
+          on: {
+            INC: ({ context, event }) => ({
+              context: { count: context.count + event.by }
+            })
+          }
+        }
+      }
+    });
+
+    const actor = createActor(machine).start();
+
+    expect(actor.getSnapshot().context.count).toBe(0);
+
+    actor.trigger.INC({ by: 5 });
+
+    expect(actor.getSnapshot().context.count).toBe(5);
+  });
+
+  it('should work with events with only type (no payload)', () => {
+    const events: string[] = [];
+
+    const machine = createMachine({
+      initial: 'a',
+      states: {
+        a: {
+          on: {
+            GO: (_, enq) => {
+              enq(() => events.push('GO'));
+              return { target: 'b' };
+            }
+          }
+        },
+        b: {}
+      }
+    });
+
+    const actor = createActor(machine).start();
+
+    actor.trigger.GO();
+
+    expect(events).toEqual(['GO']);
+    expect(actor.getSnapshot().value).toBe('b');
+  });
+
+  it('should work with multiple event types', () => {
+    const machine = createMachine({
+      schemas: {
+        context: z.object({ count: z.number() }),
+        events: {
+          INC: z.object({}),
+          DEC: z.object({}),
+          SET: z.object({ value: z.number() })
+        }
+      },
+      context: { count: 0 },
+      initial: 'active',
+      states: {
+        active: {
+          on: {
+            INC: ({ context }) => ({
+              context: { count: context.count + 1 }
+            }),
+            DEC: ({ context }) => ({
+              context: { count: context.count - 1 }
+            }),
+            SET: ({ event }) => ({
+              context: { count: event.value }
+            })
+          }
+        }
+      }
+    });
+
+    const actor = createActor(machine).start();
+
+    actor.trigger.INC();
+    expect(actor.getSnapshot().context.count).toBe(1);
+
+    actor.trigger.INC();
+    expect(actor.getSnapshot().context.count).toBe(2);
+
+    actor.trigger.DEC();
+    expect(actor.getSnapshot().context.count).toBe(1);
+
+    actor.trigger.SET({ value: 100 });
+    expect(actor.getSnapshot().context.count).toBe(100);
+  });
+});