xstate 5.0.0-alpha.6 → 5.0.0-beta.8

package/dist/{actions-bf7bb1c5.cjs.dev.js → actions-d06ca158.cjs.dev.js}

@@ -535,6 +535,9 @@ function send$1(eventOrExpr, options) {
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with sendTo; use sendTo({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
     var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (isString(params.delay)) {
@@ -832,25 +835,28 @@ promiseCreator) {
   var behavior = {
     transition: function transition(state, event) {
       var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
       var eventObject = _event.data;
       switch (_event.name) {
         case resolveEventType:
-          state.status = 'done';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            data: eventObject.data,
+            input: undefined
+          });
         case rejectEventType:
-          state.status = 'error';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            data: eventObject.data,
+            input: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined
+          });
         default:
           return state;
       }
@@ -879,7 +885,6 @@ promiseCreator) {
     },
     getInitialState: function getInitialState(_, input) {
       return {
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -914,12 +919,11 @@ function fromObservable(observableCreator) {
         id = _ref.id,
         defer = _ref.defer;
       var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
       switch (_event.name) {
         case nextEventType:
-          state.data = event.data.data;
           // match the exact timing of events sent by machines
           // send actions are not executed immediately
           defer(function () {
@@ -931,21 +935,29 @@ function fromObservable(observableCreator) {
               origin: self
             }));
           });
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            data: event.data.data
+          });
         case errorEventType:
-          state.status = 'error';
-          delete state.input;
-          state.data = _event.data.data;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            input: undefined,
+            data: _event.data.data,
+            subscription: undefined
+          });
         case completeEventType:
-          state.status = 'done';
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
           state.subscription.unsubscribe();
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          });
         default:
           return state;
       }
@@ -953,7 +965,6 @@ function fromObservable(observableCreator) {
     getInitialState: function getInitialState(_, input) {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -991,12 +1002,10 @@ function fromObservable(observableCreator) {
       return state.data;
     },
     getPersistedState: function getPersistedState(_ref3) {
-      var canceled = _ref3.canceled,
-        status = _ref3.status,
+      var status = _ref3.status,
         data = _ref3.data,
         input = _ref3.input;
       return {
-        canceled: canceled,
         status: status,
         data: data,
         input: input
@@ -1031,24 +1040,30 @@ function fromEventObservable(lazyObservable) {
   var behavior = {
     transition: function transition(state, event) {
       var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
       switch (_event.name) {
         case errorEventType:
-          state.status = 'error';
-          delete state.input;
-          state.data = _event.data.data;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            input: undefined,
+            data: _event.data.data,
+            subscription: undefined
+          });
         case completeEventType:
-          state.status = 'done';
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
           state.subscription.unsubscribe();
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          });
         default:
           return state;
       }
@@ -1056,7 +1071,6 @@ function fromEventObservable(lazyObservable) {
     getInitialState: function getInitialState() {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined
       };
@@ -1093,12 +1107,10 @@ function fromEventObservable(lazyObservable) {
       return undefined;
     },
     getPersistedState: function getPersistedState(_ref5) {
-      var canceled = _ref5.canceled,
-        status = _ref5.status,
+      var status = _ref5.status,
         data = _ref5.data,
         input = _ref5.input;
       return {
-        canceled: canceled,
         status: status,
         data: data,
         input: input
@@ -1132,7 +1144,7 @@ function fromCallback(invokeCallback) {
         var sender = function sender(eventForParent) {
           var _self$_parent;
           if (state.canceled) {
-            return state;
+            return;
           }
           (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(toSCXMLEvent(eventForParent, {
             origin: self
@@ -1247,6 +1259,12 @@ function toActorRef(actorRefLike) {
     return void 0;
   }), _objectSpread2$1), actorRefLike);
 }
+var emptyBehavior = fromTransition(function (_) {
+  return undefined;
+}, undefined);
+function createEmptyActor() {
+  return interpret(emptyBehavior);
+}
 
 function createSystem() {
   var sessionIdCounter = 0;
@@ -1650,6 +1668,9 @@ var Interpreter = /*#__PURE__*/function () {
   }, {
     key: "send",
     value: function send(event) {
+      if (typeof event === 'string') {
+        throw new Error("Only event objects may be sent to actors; use .send({ type: \"".concat(event, "\" }) instead"));
+      }
       var _event = toSCXMLEvent(event);
       if (this.status === exports.ActorStatus.Stopped) {
         // do nothing
@@ -2256,7 +2277,7 @@ function getDelayedTransitions(stateNode) {
   var mutateEntryExit = function mutateEntryExit(delay, i) {
     var delayRef = isFunction(delay) ? "".concat(stateNode.id, ":delay[").concat(i, "]") : delay;
     var eventType = after$1(delayRef, stateNode.id);
-    stateNode.entry.push(send$1({
+    stateNode.entry.push(raise$1({
       type: eventType
     }, {
       delay: delay
@@ -2291,9 +2312,9 @@ function getDelayedTransitions(stateNode) {
   });
 }
 function formatTransition(stateNode, transitionConfig) {
-  var _transitionConfig$ext;
+  var _transitionConfig$ree;
   var normalizedTarget = normalizeTarget(transitionConfig.target);
-  var external = (_transitionConfig$ext = transitionConfig.external) !== null && _transitionConfig$ext !== void 0 ? _transitionConfig$ext : false;
+  var reenter = (_transitionConfig$ree = transitionConfig.reenter) !== null && _transitionConfig$ree !== void 0 ? _transitionConfig$ree : false;
   var guards = stateNode.machine.options.guards;
   var target = resolveTarget(stateNode, normalizedTarget);
 
@@ -2308,7 +2329,7 @@ function formatTransition(stateNode, transitionConfig) {
     }) : undefined,
     target: target,
     source: stateNode,
-    external: external,
+    reenter: reenter,
     eventType: transitionConfig.event,
     toJSON: function toJSON() {
       return _objectSpread2(_objectSpread2({}, transition), {}, {
@@ -2395,7 +2416,7 @@ function formatInitialTransition(stateNode, _target) {
       source: stateNode,
       actions: [],
       eventType: null,
-      external: false,
+      reenter: false,
       target: resolvedTarget,
       toJSON: function toJSON() {
         return _objectSpread2(_objectSpread2({}, transition), {}, {
@@ -2818,7 +2839,7 @@ function getTransitionDomain(transition, historyValue) {
   if (!targetStates) {
     return null;
   }
-  if (!transition.external && transition.source.type === 'compound' && targetStates.every(function (targetStateNode) {
+  if (!transition.reenter && transition.source.type !== 'parallel' && targetStates.every(function (targetStateNode) {
     return isDescendant(targetStateNode, transition.source);
   })) {
     return transition.source;
@@ -2888,7 +2909,7 @@ function microstep(transitions, currentState, actorCtx, scxmlEvent) {
   var microstate = microstepProcedure(currentState._initial ? [{
     target: _toConsumableArray(currentState.configuration).filter(isAtomicStateNode),
     source: machine.root,
-    external: true,
+    reenter: true,
     actions: [],
     eventType: null,
     toJSON: null // TODO: fix
@@ -4048,6 +4069,9 @@ function raise$1(eventOrExpr, options) {
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with raise; use raise({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
     var resolvedEvent = toSCXMLEvent(typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (typeof params.delay === 'string') {
@@ -4098,6 +4122,27 @@ function choose$1(guards) {
   });
 }
 
+function pure$1(getActions) {
+  return createDynamicAction({
+    type: pure,
+    params: {
+      get: getActions
+    }
+  }, function (_event, _ref) {
+    var _toArray;
+    var state = _ref.state;
+    return [state, {
+      type: pure,
+      params: {
+        actions: (_toArray = toArray(toActionObjects(getActions({
+          context: state.context,
+          event: _event.data
+        })))) !== null && _toArray !== void 0 ? _toArray : []
+      }
+    }];
+  });
+}
+
 var initEvent = toSCXMLEvent({
   type: init
 });
@@ -4270,7 +4315,7 @@ exports.and = and;
 exports.assign = assign$1;
 exports.cancel = cancel$1;
 exports.choose = choose$1;
-exports.createDynamicAction = createDynamicAction;
+exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
 exports.createSpawner = createSpawner;
@@ -4314,7 +4359,7 @@ exports.microstep = microstep;
 exports.not = not;
 exports.or = or;
 exports.pathToStateValue = pathToStateValue;
-exports.pure = pure;
+exports.pure = pure$1;
 exports.raise = raise$1;
 exports.resolveActionObject = resolveActionObject;
 exports.resolveActionsAndContext = resolveActionsAndContext;

package/dist/declarations/src/StateMachine.d.ts

@@ -1,7 +1,7 @@
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
@@ -21,7 +21,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     delimiter: string;
     options: MachineImplementationsSimplified<TContext, TEvent>;
-    schema: MachineSchema<TContext, TEvent>;
+    types: MachineTypes<TContext, TEvent>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;

package/dist/declarations/src/actions.d.ts

@@ -7,6 +7,7 @@ export { cancel } from './actions/cancel.ts';
 export { assign } from './actions/assign.ts';
 export { raise } from './actions/raise.ts';
 export { choose } from './actions/choose.ts';
+export { pure } from './actions/pure.ts';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;

package/dist/declarations/src/actors/index.d.ts

@@ -1,4 +1,4 @@
-import type { EventObject, ActorRef, BaseActorRef } from '../types.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
 export { fromTransition } from './transition.ts';
 export { fromPromise } from './promise.ts';
 export { fromObservable, fromEventObservable } from './observable.ts';
@@ -25,3 +25,4 @@ export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType
 export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
 export declare function isActorRef(item: any): item is ActorRef<any>;
 export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
+export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;

package/dist/declarations/src/actors/observable.d.ts

@@ -1,8 +1,7 @@
 import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
-    canceled: boolean;
-    status: 'active' | 'done' | 'error';
+    status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
     input?: any;
 }

package/dist/declarations/src/actors/promise.d.ts

@@ -1,7 +1,6 @@
 import { ActorBehavior } from '../types';
 export interface PromiseInternalState<T> {
-    status: 'active' | 'error' | 'done';
-    canceled: boolean;
+    status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }

package/dist/declarations/src/index.d.ts

@@ -1,42 +1,26 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.ts';
-import { assign } from './actions/assign.ts';
-import { cancel } from './actions/cancel.ts';
-import { choose } from './actions/choose.ts';
-import { log } from './actions/log.ts';
-import { pure } from './actions/pure.ts';
-import { raise } from './actions/raise.ts';
-import { send } from './actions/send.ts';
-import { stop } from './actions/stop.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
+export { assign } from './actions/assign.ts';
+export { cancel } from './actions/cancel.ts';
+export { choose } from './actions/choose.ts';
+export { log } from './actions/log.ts';
+export { pure } from './actions/pure.ts';
+export { raise } from './actions/raise.ts';
+export { stop } from './actions/stop.ts';
 import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
 import { createMachine } from './Machine.ts';
 import { mapState } from './mapState.ts';
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
-export { createSchema, t } from './schema.ts';
 export { SimulatedClock } from './SimulatedClock.ts';
 export { StateMachine } from './StateMachine.ts';
 export { getStateNodes } from './stateUtils.ts';
+export { waitFor } from './waitFor.ts';
 export * from './typegenTypes.ts';
 export * from './types.ts';
 export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
-export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    log: typeof log;
-    cancel: typeof cancel;
-    stop: typeof stop;
-    assign: typeof assign;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
+export { stateIn, not, and, or } from './guards.ts';
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/dist/declarations/src/types.d.ts

@@ -161,7 +161,7 @@ export type TransitionTarget = SingleOrArray<string>;
 export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TAction extends ParameterizedObject = ParameterizedObject> {
     guard?: GuardConfig<TContext, TExpressionEvent>;
     actions?: BaseActions<TContext, TExpressionEvent, TEvent, TAction>;
-    external?: boolean;
+    reenter?: boolean;
     target?: TransitionTarget | undefined;
     meta?: Record<string, any>;
     description?: string;
@@ -490,13 +490,12 @@ export interface MachineConfig<TContext extends MachineContext, TEvent extends E
      * If `true`, will use SCXML semantics, such as event token matching.
      */
     scxml?: boolean;
-    schema?: MachineSchema<TContext, TEvent, TActorMap>;
-    tsTypes?: TTypesMeta;
+    types?: MachineTypes<TContext, TEvent, TActorMap, TTypesMeta>;
 }
 export type ActorMap = Record<string, {
     output: any;
 }>;
-export interface MachineSchema<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap> {
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta = TypegenDisabled> {
     context?: TContext;
     actions?: {
         type: string;
@@ -508,6 +507,7 @@ export interface MachineSchema<TContext extends MachineContext, TEvent extends E
         type: string;
         [key: string]: any;
     };
+    typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
@@ -731,7 +731,7 @@ export interface TransitionDefinition<TContext extends MachineContext, TEvent ex
     target: Array<StateNode<TContext, TEvent>> | undefined;
     source: StateNode<TContext, TEvent>;
     actions: BaseActionObject[];
-    external: boolean;
+    reenter: boolean;
     guard?: GuardDefinition<TContext, TEvent>;
     eventType: TEvent['type'] | '*';
     toJSON: () => {

package/dist/declarations/src/waitFor.d.ts

@@ -0,0 +1,33 @@
+import { ActorRef, SnapshotFrom } from '.';
+interface WaitForOptions {
+    /**
+     * How long to wait before rejecting, if no emitted
+     * state satisfies the predicate.
+     *
+     * @default 10_000 (10 seconds)
+     */
+    timeout: number;
+}
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy
+ * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
+ *
+ * @example
+ * ```js
+ * const state = await waitFor(someService, state => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value
+ * that matches the condition
+ */
+export declare function waitFor<TActorRef extends ActorRef<any, any>>(actorRef: TActorRef, predicate: (emitted: SnapshotFrom<TActorRef>) => boolean, options?: Partial<WaitForOptions>): Promise<SnapshotFrom<TActorRef>>;
+export {};