[v5] Actor status object

packages/core/src/StateMachine.ts

@@ -406,14 +406,14 @@
       : new State(stateConfig, this);
   }
 
   public getStatus(
     state: State<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>
   ) {
     return state.error
-      ? { status: 'error', data: state.error }
+      ? { status: 'error' as const, error: state.error }
       : state.done
-      ? { status: 'done', data: state.output }
-      : { status: 'active' };
+      ? { status: 'done' as const, output: state.output! }
+      : { status: 'active' as const };
   }
 
   public restoreState(

packages/core/src/actors/observable.ts

@@ -5,15 +5,18 @@
   EventObject,
   Subscription,
   AnyActorSystem,
-  ActorRefFrom
+  ActorRefFrom,
+  ActorStatusObject,
+  TODO
 } from '../types';
 
-export interface ObservableInternalState<T, TInput = unknown> {
+export type ObservableInternalState<
+  T,
+  TInput = unknown
+> = ActorStatusObject<T> & {
   subscription: Subscription | undefined;
-  status: 'active' | 'done' | 'error' | 'canceled';
-  data: T | undefined;
   input: TInput | undefined;
-}
+};
 
 export type ObservablePersistedState<T, TInput = unknown> = Omit<
   ObservableInternalState<T, TInput>,
@@ -47,7 +50,7 @@
 
   return {
     config: observableCreator,
     transition: (state, event, { self, id, defer }) => {
       if (state.status !== 'active') {
         return state;
       }
@@ -64,14 +67,15 @@
           });
           return {
             ...state,
-            data: (event as any).data
+            output: (event as any).data
           };
         case errorEventType:
           return {
             ...state,
             status: 'error',
+            error: (event as any).data,
             input: undefined,
-            data: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
+            output: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
             subscription: undefined
           };
         case completeEventType:
@@ -97,8 +101,9 @@
       return {
         subscription: undefined,
         status: 'active',
-        data: undefined,
-        input
+        output: undefined,
+        input,
+        error: undefined
       };
     },
     start: (state, { self, system }) => {
@@ -122,14 +127,10 @@
         }
       });
     },
-    getSnapshot: (state) => state.data,
-    getPersistedState: ({ status, data, input }) => ({
-      status,
-      data,
-      input
-    }),
+    getSnapshot: (state) => state.output,
+    getPersistedState: (state) => state,
     getStatus: (state) => state,
     restoreState: (state) => ({
       ...state,
       subscription: undefined
     })
@@ -161,7 +162,7 @@
   // TODO: event types
   return {
     config: lazyObservable,
     transition: (state, event) => {
       if (state.status !== 'active') {
         return state;
       }
@@ -172,7 +173,7 @@
             ...state,
             status: 'error',
             input: undefined,
-            data: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
+            error: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
             subscription: undefined
           };
         case completeEventType:
@@ -194,11 +195,11 @@
           return state;
       }
     },
     getInitialState: (_, input) => {
       return {
         subscription: undefined,
         status: 'active',
-        data: undefined,
+        output: undefined,
         input
       };
     },
@@ -225,15 +226,12 @@
       });
     },
     getSnapshot: (_) => undefined,
-    getPersistedState: ({ status, data, input }) => ({
-      status,
-      data,
-      input
-    }),
+    getPersistedState: (state) => state,
     getStatus: (state) => state,
-    restoreState: (state) => ({
-      ...state,
-      subscription: undefined
-    })
+    restoreState: (state) =>
+      ({
+        ...state,
+        subscription: undefined
+      } as TODO)
   };
 }

packages/core/src/actors/promise.ts

@@ -2,13 +2,14 @@ import {
   ActorLogic,
   ActorRefFrom,
   ActorSystem,
-  AnyActorSystem
+  AnyActorSystem,
+  TODO
 } from '../types';
 import { XSTATE_STOP } from '../constants';
 
 export interface PromiseInternalState<T, TInput = unknown> {
-  status: 'active' | 'error' | 'done' | 'canceled';
-  data: T | undefined;
+  status: 'active' | 'error' | 'done' | 'stopped';
+  output: T | undefined;
   input: TInput | undefined;
 }
 
@@ -64,20 +65,20 @@ export function fromPromise<T, TInput>(
           return {
             ...state,
             status: 'done',
-            data: (event as any).data,
+            output: (event as any).data,
             input: undefined
           };
         case rejectEventType:
           return {
             ...state,
             status: 'error',
-            data: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
+            error: (event as any).data, // TODO: if we keep this as `data` we should reflect this in the type
             input: undefined
           };
         case XSTATE_STOP:
           return {
             ...state,
-            status: 'canceled',
+            status: 'stopped',
             input: undefined
           };
         default:
@@ -115,12 +116,12 @@ export function fromPromise<T, TInput>(
     getInitialState: (_, input) => {
       return {
         status: 'active',
-        data: undefined,
+        output: undefined,
         input
       };
     },
-    getSnapshot: (state) => state.data,
-    getStatus: (state) => state,
+    getSnapshot: (state) => state.output,
+    getStatus: (state) => state as TODO,
     getPersistedState: (state) => state,
     restoreState: (state) => state
   };

packages/core/src/interpreter.ts

@@ -20,6 +20,7 @@ import type {
   PersistedStateFrom,
   SnapshotFrom,
   AnyActorRef,
+  OutputFrom,
   DoneActorEvent
 } from './types.ts';
 import {
@@ -80,7 +81,7 @@ type InternalStateFrom<TLogic extends ActorLogic<any, any, any>> =
 export class Actor<
   TLogic extends AnyActorLogic,
   TEvent extends EventObject = EventFromLogic<TLogic>
-> implements ActorRef<TEvent, SnapshotFrom<TLogic>>
+> implements ActorRef<TEvent, SnapshotFrom<TLogic>, OutputFrom<TLogic>>
 {
   /**
    * The current internal state of the actor.
@@ -219,13 +220,13 @@ export class Actor<
       case 'done':
         this._stopProcedure();
         this._complete();
-        this._doneEvent = createDoneActorEvent(this.id, status.data);
+        this._doneEvent = createDoneActorEvent(this.id, status.output);
         this._parent?.send(this._doneEvent as any);
         break;
       case 'error':
         this._stopProcedure();
-        this._error(status.data);
-        this._parent?.send(createErrorActorEvent(this.id, status.data));
+        this._error(status.error);
+        this._parent?.send(createErrorActorEvent(this.id, status.error));
         break;
     }
   }
@@ -319,6 +320,10 @@ export class Actor<
     return this;
   }
 
+  public getStatus() {
+    return this.logic.getStatus!(this._state);
+  }
+
   private _process(event: TEvent) {
     // TODO: reexamine what happens when an action (or a guard or smth) throws
     let nextState;

packages/core/src/types.ts

@@ -1823,8 +1823,11 @@ export interface ActorLike<TCurrent, TEvent extends EventObject>
   send: (event: TEvent) => void;
 }
 
-export interface ActorRef<TEvent extends EventObject, TSnapshot = any>
-  extends Subscribable<TSnapshot>,
+export interface ActorRef<
+  TEvent extends EventObject,
+  TSnapshot = any,
+  TOutput = unknown
+> extends Subscribable<TSnapshot>,
     InteropObservable<TSnapshot> {
   /**
    * The unique identifier for this actor relative to its parent.
@@ -1837,6 +1840,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot = any>
   getSnapshot: () => TSnapshot;
   // TODO: this should return some sort of TPersistedState, not any
   getPersistedState?: () => any;
+  getStatus: () => ActorStatusObject<TOutput>;
   stop: () => void;
   toJSON?: () => any;
   // TODO: figure out how to hide this externally as `sendTo(ctx => ctx.actorRef._parent._parent._parent._parent)` shouldn't be allowed
@@ -1988,6 +1992,28 @@ export interface ActorContext<
 
 export type AnyActorContext = ActorContext<any, any, any>;
 
+export type ActorStatusObject<TOutput> =
+  | {
+      status: 'done';
+      output: TOutput;
+      error: undefined;
+    }
+  | {
+      status: 'error';
+      output: undefined;
+      error: unknown;
+    }
+  | {
+      status: 'stopped';
+      output: TOutput | undefined;
+      error: unknown | undefined;
+    }
+  | {
+      status: 'active';
+      output: undefined;
+      error: undefined;
+    };
+
 export interface ActorLogic<
   TEvent extends EventObject,
   TSnapshot = any,
@@ -2015,7 +2041,7 @@ export interface ActorLogic<
     actorCtx: ActorContext<TEvent, TSnapshot>
   ) => TInternalState;
   getSnapshot?: (state: TInternalState) => TSnapshot;
-  getStatus?: (state: TInternalState) => { status: string; data?: any };
+  getStatus?: (state: TInternalState) => ActorStatusObject<TOutput>;
   start?: (
     state: TInternalState,
     actorCtx: ActorContext<TEvent, TSnapshot>

packages/core/test/actorLogic.test.ts

@@ -128,7 +128,7 @@ describe('promise logic (fromPromise)', () => {
 
       expect(resolvedPersistedState).toEqual(
         expect.objectContaining({
-          data: 42
+          output: 42
         })
       );
 
@@ -154,7 +154,7 @@ describe('promise logic (fromPromise)', () => {
     const resolvedPersistedState = actor.getPersistedState();
     expect(resolvedPersistedState).toEqual(
       expect.objectContaining({
-        data: 1
+        output: 1
       })
     );
     expect(createdPromises).toBe(1);
@@ -182,16 +182,15 @@ describe('promise logic (fromPromise)', () => {
     const rejectedPersistedState = actor.getPersistedState();
     expect(rejectedPersistedState).toEqual(
       expect.objectContaining({
-        data: 1
+        error: 1
       })
     );
     expect(createdPromises).toBe(1);
 
-    const restoredActor = createActor(promiseLogic, {
+    createActor(promiseLogic, {
       state: rejectedPersistedState
     }).start();
 
-    expect(restoredActor.getSnapshot()).toBe(1);
     expect(createdPromises).toBe(1);
   });
 
@@ -532,7 +531,7 @@ describe('machine logic', () => {
     expect(persistedState.children.a.state).toEqual(
       expect.objectContaining({
         status: 'done',
-        data: 42
+        output: 42
       })
     );
 

packages/xstate-react/test/useSelector.test.tsx

@@ -343,7 +343,8 @@ describeEachReactMode('useSelector (%s)', ({ suiteKey, render }) => {
           return { unsubscribe: () => {} };
         },
         getSnapshot: () => latestValue,
-        getInitialState: () => latestValue
+        getInitialState: () => latestValue,
+        getOutput: () => undefined
       });
 
     const parentMachine = createMachine({
@@ -485,7 +486,8 @@ describeEachReactMode('useSelector (%s)', ({ suiteKey, render }) => {
           return { unsubscribe: () => {} };
         },
         getSnapshot: () => latestValue,
-        getInitialState: () => latestValue
+        getInitialState: () => latestValue,
+        getOutput: () => undefined
       });
 
     const parentMachine = createMachine({
@@ -522,7 +524,8 @@ describeEachReactMode('useSelector (%s)', ({ suiteKey, render }) => {
           return { unsubscribe: () => {} };
         },
         getSnapshot: () => latestValue,
-        getInitialState: () => latestValue
+        getInitialState: () => latestValue,
+        getOutput: () => undefined
       });
 
     const actor1 = createCustomActor('foo');
@@ -553,7 +556,8 @@ describeEachReactMode('useSelector (%s)', ({ suiteKey, render }) => {
         return { unsubscribe: () => {} };
       },
       getSnapshot: () => undefined,
-      getInitialState: () => undefined
+      getInitialState: () => undefined,
+      getOutput: () => undefined
     });
 
     const App = ({ selector }: { selector: any }) => {

packages/xstate-solid/test/useActor.test.tsx

@@ -25,7 +25,8 @@ const createSimpleActor = <T extends unknown>(value: T) =>
   createActor({
     transition: (s) => s,
     getSnapshot: () => value,
-    getInitialState: () => value
+    getInitialState: () => value,
+    getOutput: () => undefined
   });
 
 describe('useActor', () => {
@@ -651,7 +652,8 @@ describe('useActor', () => {
     const simpleActor = createActor({
       transition: (s) => s,
       getSnapshot: () => 42,
-      getInitialState: () => 42
+      getInitialState: () => 42,
+      getOutput: () => undefined
     });
 
     const Test = () => {