xstate 5.0.0-beta.26 → 5.0.0-beta.28

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

@@ -2,21 +2,446 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('../../dist/actions-319cefe7.cjs.js');
+var interpreter = require('../../dist/interpreter-672794ae.cjs.js');
 require('../../dev/dist/xstate-dev.cjs.js');
 
+/**
+ * Returns actor logic from a transition function and its initial state.
+ *
+ * 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.
+ * @returns Actor logic
+ */
+function fromTransition(transition, initialState) {
+  return {
+    config: transition,
+    transition: (state, event, actorContext) => {
+      return transition(state, event, actorContext);
+    },
+    getInitialState: (_, input) => {
+      return typeof initialState === 'function' ? initialState({
+        input
+      }) : initialState;
+    },
+    getSnapshot: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
+  };
+}
 
+function fromCallback(invokeCallback) {
+  return {
+    config: invokeCallback,
+    start: (_state, {
+      self
+    }) => {
+      self.send({
+        type: interpreter.XSTATE_INIT
+      });
+    },
+    transition: (state, event, {
+      self,
+      id,
+      system
+    }) => {
+      if (event.type === interpreter.XSTATE_INIT) {
+        const sendBack = eventForParent => {
+          if (state.canceled) {
+            return;
+          }
+          self._parent?.send(eventForParent);
+        };
+        const receive = newListener => {
+          state.receivers.add(newListener);
+        };
+        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();
+        }
+        return state;
+      }
+      state.receivers.forEach(receiver => receiver(event));
+      return state;
+    },
+    getInitialState: (_, input) => {
+      return {
+        canceled: false,
+        receivers: new Set(),
+        dispose: undefined,
+        input
+      };
+    },
+    getSnapshot: () => undefined,
+    getPersistedState: ({
+      input,
+      canceled
+    }) => ({
+      input,
+      canceled
+    })
+  };
+}
 
-exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
-exports.fromCallback = actors_dist_xstateActors.fromCallback;
-exports.fromEventObservable = actors_dist_xstateActors.fromEventObservable;
-exports.fromObservable = actors_dist_xstateActors.fromObservable;
-exports.fromPromise = actors_dist_xstateActors.fromPromise;
-exports.fromTransition = actors_dist_xstateActors.fromTransition;
-exports.isActorRef = actors_dist_xstateActors.isActorRef;
-exports.isSignal = actors_dist_xstateActors.isSignal;
-exports.startSignal = actors_dist_xstateActors.startSignal;
-exports.startSignalType = actors_dist_xstateActors.startSignalType;
-exports.stopSignal = actors_dist_xstateActors.stopSignal;
-exports.stopSignalType = actors_dist_xstateActors.stopSignalType;
-exports.toActorRef = actors_dist_xstateActors.toActorRef;
+function fromObservable(observableCreator) {
+  const nextEventType = '$$xstate.next';
+  const errorEventType = '$$xstate.error';
+  const completeEventType = '$$xstate.complete';
+  return {
+    config: observableCreator,
+    transition: (state, event, {
+      self,
+      id,
+      defer
+    }) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      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
+            });
+          });
+          return {
+            ...state,
+            data: event.data
+          };
+        case errorEventType:
+          return {
+            ...state,
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            // TODO: if we keep this as `data` we should reflect this in the type
+            subscription: undefined
+          };
+        case completeEventType:
+          return {
+            ...state,
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          };
+        case interpreter.XSTATE_STOP:
+          state.subscription.unsubscribe();
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    getInitialState: (_, input) => {
+      return {
+        subscription: undefined,
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      if (state.status === 'done') {
+        // Do not restart a completed observable
+        return;
+      }
+      state.subscription = observableCreator({
+        input: state.input,
+        system,
+        self
+      }).subscribe({
+        next: value => {
+          self.send({
+            type: nextEventType,
+            data: value
+          });
+        },
+        error: err => {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: () => {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+    },
+    getSnapshot: state => state.data,
+    getPersistedState: ({
+      status,
+      data,
+      input
+    }) => ({
+      status,
+      data,
+      input
+    }),
+    getStatus: state => state,
+    restoreState: state => ({
+      ...state,
+      subscription: undefined
+    })
+  };
+}
+
+/**
+ * Creates event observable logic that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns Event observable logic
+ */
+
+function fromEventObservable(lazyObservable) {
+  const errorEventType = '$$xstate.error';
+  const completeEventType = '$$xstate.complete';
+
+  // TODO: event types
+  return {
+    config: lazyObservable,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case errorEventType:
+          return {
+            ...state,
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            // TODO: if we keep this as `data` we should reflect this in the type
+            subscription: undefined
+          };
+        case completeEventType:
+          return {
+            ...state,
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          };
+        case interpreter.XSTATE_STOP:
+          state.subscription.unsubscribe();
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    getInitialState: (_, input) => {
+      return {
+        subscription: undefined,
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      if (state.status === 'done') {
+        // Do not restart a completed observable
+        return;
+      }
+      state.subscription = lazyObservable({
+        input: state.input,
+        system,
+        self
+      }).subscribe({
+        next: value => {
+          self._parent?.send(value);
+        },
+        error: err => {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: () => {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+    },
+    getSnapshot: _ => undefined,
+    getPersistedState: ({
+      status,
+      data,
+      input
+    }) => ({
+      status,
+      data,
+      input
+    }),
+    getStatus: state => state,
+    restoreState: state => ({
+      ...state,
+      subscription: undefined
+    })
+  };
+}
+
+const resolveEventType = '$$xstate.resolve';
+const rejectEventType = '$$xstate.reject';
+function fromPromise(
+// TODO: add types
+promiseCreator) {
+  // TODO: add event types
+  const logic = {
+    config: promiseCreator,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case resolveEventType:
+          return {
+            ...state,
+            status: 'done',
+            data: event.data,
+            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
+            input: undefined
+          };
+        case interpreter.XSTATE_STOP:
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      // TODO: determine how to allow customizing this so that promises
+      // can be restarted if necessary
+      if (state.status !== 'active') {
+        return;
+      }
+      const resolvedPromise = Promise.resolve(promiseCreator({
+        input: state.input,
+        system,
+        self
+      }));
+      resolvedPromise.then(response => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: resolveEventType,
+          data: response
+        });
+      }, errorData => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: rejectEventType,
+          data: errorData
+        });
+      });
+    },
+    getInitialState: (_, input) => {
+      return {
+        status: 'active',
+        data: 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);
+}
+
+exports.createEmptyActor = createEmptyActor;
+exports.fromCallback = fromCallback;
+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

@@ -6,10 +6,5 @@ export {
   fromPromise,
   fromTransition,
   isActorRef,
-  isSignal,
-  startSignal,
-  startSignalType,
-  stopSignal,
-  stopSignalType,
   toActorRef
 } from "./xstate-actors.cjs.js";