xstate 5.0.0-beta.28 → 5.0.0-beta.30

package/actors/dist/xstate-actors.cjs.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var interpreter = require('../../dist/interpreter-672794ae.cjs.js');
+var interpreter = require('../../dist/interpreter-a2c1e529.cjs.js');
 require('../../dev/dist/xstate-dev.cjs.js');
 
 /**
@@ -11,21 +11,28 @@ require('../../dev/dist/xstate-dev.cjs.js');
  * A transition function is a function that takes the current state and an event and returns the next state.
  *
  * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
+ * @param initialContext The initial state of the transition function.
  * @returns Actor logic
  */
-function fromTransition(transition, initialState) {
+function fromTransition(transition, initialContext) {
   return {
     config: transition,
     transition: (state, event, actorContext) => {
-      return transition(state, event, actorContext);
+      return {
+        ...state,
+        context: transition(state.context, event, actorContext)
+      };
     },
     getInitialState: (_, input) => {
-      return typeof initialState === 'function' ? initialState({
-        input
-      }) : initialState;
+      return {
+        status: 'active',
+        output: undefined,
+        error: undefined,
+        context: typeof initialContext === 'function' ? initialContext({
+          input
+        }) : initialContext
+      };
     },
-    getSnapshot: state => state,
     getPersistedState: state => state,
     restoreState: state => state
   };
@@ -48,58 +55,52 @@ function fromCallback(invokeCallback) {
     }) => {
       if (event.type === interpreter.XSTATE_INIT) {
         const sendBack = eventForParent => {
-          if (state.canceled) {
+          if (state.status === 'stopped') {
             return;
           }
           self._parent?.send(eventForParent);
         };
         const receive = newListener => {
-          state.receivers.add(newListener);
+          state._receivers.add(newListener);
         };
-        state.dispose = invokeCallback({
+        state._dispose = invokeCallback({
           input: state.input,
           system,
           self: self,
           sendBack,
           receive
         });
-        if (interpreter.isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(interpreter.createDoneActorEvent(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(interpreter.createErrorActorEvent(id, errorData));
-          });
-        }
         return state;
       }
       if (event.type === interpreter.XSTATE_STOP) {
-        state.canceled = true;
-        if (typeof state.dispose === 'function') {
-          state.dispose();
+        state = {
+          ...state,
+          status: 'stopped',
+          error: undefined
+        };
+        if (typeof state._dispose === 'function') {
+          state._dispose();
         }
         return state;
       }
-      state.receivers.forEach(receiver => receiver(event));
+      state._receivers.forEach(receiver => receiver(event));
       return state;
     },
     getInitialState: (_, input) => {
       return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
-        input
+        status: 'active',
+        output: undefined,
+        error: undefined,
+        input,
+        _receivers: new Set(),
+        _dispose: undefined
       };
     },
-    getSnapshot: () => undefined,
     getPersistedState: ({
-      input,
-      canceled
-    }) => ({
-      input,
-      canceled
-    })
+      _dispose,
+      _receivers,
+      ...rest
+    }) => rest
   };
 }
 
@@ -109,62 +110,66 @@ function fromObservable(observableCreator) {
   const completeEventType = '$$xstate.complete';
   return {
     config: observableCreator,
-    transition: (state, event, {
+    transition: (snapshot, event, {
       self,
       id,
       defer
     }) => {
-      if (state.status !== 'active') {
-        return state;
+      if (snapshot.status !== 'active') {
+        return snapshot;
       }
       switch (event.type) {
         case nextEventType:
-          // match the exact timing of events sent by machines
-          // send actions are not executed immediately
-          defer(() => {
-            self._parent?.send({
-              type: `xstate.snapshot.${id}`,
-              data: event.data
+          {
+            const newSnapshot = {
+              ...snapshot,
+              context: event.data
+            };
+            // match the exact timing of events sent by machines
+            // send actions are not executed immediately
+            defer(() => {
+              self._parent?.send({
+                type: `xstate.snapshot.${id}`,
+                data: newSnapshot
+              });
             });
-          });
-          return {
-            ...state,
-            data: event.data
-          };
+            return newSnapshot;
+          }
         case errorEventType:
           return {
-            ...state,
+            ...snapshot,
             status: 'error',
+            error: event.data,
             input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
+            _subscription: undefined
           };
         case completeEventType:
           return {
-            ...state,
+            ...snapshot,
             status: 'done',
             input: undefined,
-            subscription: undefined
+            _subscription: undefined
           };
         case interpreter.XSTATE_STOP:
-          state.subscription.unsubscribe();
+          snapshot._subscription.unsubscribe();
           return {
-            ...state,
-            status: 'canceled',
+            ...snapshot,
+            status: 'stopped',
             input: undefined,
-            subscription: undefined
+            _subscription: undefined
           };
         default:
-          return state;
+          return snapshot;
       }
     },
     getInitialState: (_, input) => {
       return {
-        subscription: undefined,
         status: 'active',
-        data: undefined,
-        input
+        output: undefined,
+        error: undefined,
+        context: undefined,
+        input,
+        _subscription: undefined
       };
     },
     start: (state, {
@@ -175,7 +180,7 @@ function fromObservable(observableCreator) {
         // Do not restart a completed observable
         return;
       }
-      state.subscription = observableCreator({
+      state._subscription = observableCreator({
         input: state.input,
         system,
         self
@@ -199,20 +204,13 @@ function fromObservable(observableCreator) {
         }
       });
     },
-    getSnapshot: state => state.data,
     getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
+      _subscription,
+      ...state
+    }) => state,
     restoreState: state => ({
       ...state,
-      subscription: undefined
+      _subscription: undefined
     })
   };
 }
@@ -242,25 +240,24 @@ function fromEventObservable(lazyObservable) {
           return {
             ...state,
             status: 'error',
+            error: event.data,
             input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
+            _subscription: undefined
           };
         case completeEventType:
           return {
             ...state,
             status: 'done',
             input: undefined,
-            subscription: undefined
+            _subscription: undefined
           };
         case interpreter.XSTATE_STOP:
-          state.subscription.unsubscribe();
+          state._subscription.unsubscribe();
           return {
             ...state,
-            status: 'canceled',
+            status: 'stopped',
             input: undefined,
-            subscription: undefined
+            _subscription: undefined
           };
         default:
           return state;
@@ -268,10 +265,12 @@ function fromEventObservable(lazyObservable) {
     },
     getInitialState: (_, input) => {
       return {
-        subscription: undefined,
         status: 'active',
-        data: undefined,
-        input
+        output: undefined,
+        error: undefined,
+        context: undefined,
+        input,
+        _subscription: undefined
       };
     },
     start: (state, {
@@ -282,7 +281,7 @@ function fromEventObservable(lazyObservable) {
         // Do not restart a completed observable
         return;
       }
-      state.subscription = lazyObservable({
+      state._subscription = lazyObservable({
         input: state.input,
         system,
         self
@@ -303,20 +302,13 @@ function fromEventObservable(lazyObservable) {
         }
       });
     },
-    getSnapshot: _ => undefined,
     getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
+      _subscription,
+      ...state
+    }) => state,
     restoreState: state => ({
       ...state,
-      subscription: undefined
+      _subscription: undefined
     })
   };
 }
@@ -335,24 +327,26 @@ promiseCreator) {
       }
       switch (event.type) {
         case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
+          {
+            const resolvedValue = event.data;
+            return {
+              ...state,
+              status: 'done',
+              output: resolvedValue,
+              input: undefined
+            };
+          }
         case rejectEventType:
           return {
             ...state,
             status: 'error',
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
+            error: event.data,
             input: undefined
           };
         case interpreter.XSTATE_STOP:
           return {
             ...state,
-            status: 'canceled',
+            status: 'stopped',
             input: undefined
           };
         default:
@@ -374,8 +368,7 @@ promiseCreator) {
         self
       }));
       resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
+        if (self.getSnapshot().status !== 'active') {
           return;
         }
         self.send({
@@ -383,8 +376,7 @@ promiseCreator) {
           data: response
         });
       }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
+        if (self.getSnapshot().status !== 'active') {
           return;
         }
         self.send({
@@ -396,42 +388,17 @@ promiseCreator) {
     getInitialState: (_, input) => {
       return {
         status: 'active',
-        data: undefined,
+        output: undefined,
+        error: undefined,
         input
       };
     },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
     getPersistedState: state => state,
     restoreState: state => state
   };
   return logic;
 }
 
-function isActorRef(item) {
-  return !!item && typeof item === 'object' && typeof item.send === 'function';
-}
-
-// TODO: refactor the return type, this could be written in a better way
-// but it's best to avoid unneccessary breaking changes now
-// @deprecated use `interpret(actorLogic)` instead
-function toActorRef(actorRefLike) {
-  return {
-    subscribe: () => ({
-      unsubscribe: () => void 0
-    }),
-    id: 'anonymous',
-    sessionId: '',
-    getSnapshot: () => undefined,
-    // TODO: this isn't safe
-    [interpreter.symbolObservable]: function () {
-      return this;
-    },
-    status: interpreter.ActorStatus.Running,
-    stop: () => void 0,
-    ...actorRefLike
-  };
-}
 const emptyLogic = fromTransition(_ => undefined, undefined);
 function createEmptyActor() {
   return interpreter.createActor(emptyLogic);
@@ -443,5 +410,3 @@ exports.fromEventObservable = fromEventObservable;
 exports.fromObservable = fromObservable;
 exports.fromPromise = fromPromise;
 exports.fromTransition = fromTransition;
-exports.isActorRef = isActorRef;
-exports.toActorRef = toActorRef;

package/actors/dist/xstate-actors.cjs.mjs

@@ -4,7 +4,5 @@ export {
   fromEventObservable,
   fromObservable,
   fromPromise,
-  fromTransition,
-  isActorRef,
-  toActorRef
+  fromTransition
 } from "./xstate-actors.cjs.js";