xstate 4.30.4 → 4.31.0

package/es/interpreter.js

@@ -1,16 +1,16 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
 import { ActionTypes, SpecialTargets } from './types.js';
+import { isStateConfig, State, bindActionToState } from './State.js';
 import { errorPlatform, log, stop, start, cancel, send, update, error as error$1 } from './actionTypes.js';
+import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
 import { IS_PRODUCTION } from './environment.js';
 import { warn, mapContext, isFunction, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
-import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
-import { provide, consume } from './serviceScope.js';
+import { Scheduler } from './scheduler.js';
 import { isSpawnedActor, createDeferredActor } from './Actor.js';
 import { isInFinalState } from './stateUtils.js';
-import { isStateConfig, State, bindActionToState } from './State.js';
-import { Scheduler } from './scheduler.js';
 import { registry } from './registry.js';
-import { registerService, getGlobal } from './devTools.js';
+import { getGlobal, registerService } from './devTools.js';
+import { provide, consume } from './serviceScope.js';
 import { spawnBehavior } from './behaviors.js';
 
 var DEFAULT_SPAWN_OPTIONS = {
@@ -24,8 +24,6 @@ var InterpreterStatus;
   InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
   InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
 })(InterpreterStatus || (InterpreterStatus = {}));
-/** @ts-ignore [symbolObservable] creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
-
 
 var Interpreter =
 /*#__PURE__*/
@@ -46,7 +44,6 @@ function () {
     }
 
     this.machine = machine;
-    this.scheduler = new Scheduler();
     this.delayedEventsMap = {};
     this.listeners = new Set();
     this.contextListeners = new Set();
@@ -363,12 +360,16 @@ function () {
 
     this.listeners.add(listener); // Send current state to listener
 
-    if (this.status === InterpreterStatus.Running) {
+    if (this.status !== InterpreterStatus.NotStarted) {
       listener(this.state);
     }
 
     if (resolvedCompleteListener) {
-      this.onDone(resolvedCompleteListener);
+      if (this.status === InterpreterStatus.Stopped) {
+        resolvedCompleteListener();
+      } else {
+        this.onDone(resolvedCompleteListener);
+      }
     }
 
     return {
@@ -455,7 +456,13 @@ function () {
     if (this.status === InterpreterStatus.Running) {
       // Do not restart the service if it is already started
       return this;
-    }
+    } // yes, it's a hack but we need the related cache to be populated for some things to work (like delayed transitions)
+    // this is usually called by `machine.getInitialState` but if we rehydrate from a state we might bypass this call
+    // we also don't want to call this method here as it resolves the full initial state which might involve calling assign actions
+    // and that could potentially lead to some unwanted side-effects (even such as creating some rogue actors)
+
+
+    this.machine._init();
 
     registry.register(this.sessionId, this);
     this.initialized = true;
@@ -590,6 +597,7 @@ function () {
         child.stop();
       }
     });
+    this.children.clear();
 
     try {
       // Cancel all delayed events
@@ -610,8 +618,12 @@ function () {
     }
 
     this.scheduler.clear();
+    this.scheduler = new Scheduler({
+      deferEvents: this.options.deferEvents
+    });
     this.initialized = false;
     this.status = InterpreterStatus.Stopped;
+    this._initialState = undefined;
     registry.free(this.sessionId);
     return this;
   };
@@ -1310,8 +1322,6 @@ function () {
       id: this.id
     };
   };
-  /** @ts-ignore this creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
-
 
   Interpreter.prototype[symbolObservable] = function () {
     return this;
@@ -1332,23 +1342,20 @@ function () {
    */
 
 
-  Interpreter.defaultOptions = /*#__PURE__*/function (global) {
-    return {
-      execute: true,
-      deferEvents: true,
-      clock: {
-        setTimeout: function (fn, ms) {
-          return setTimeout(fn, ms);
-        },
-        clearTimeout: function (id) {
-          return clearTimeout(id);
-        }
+  Interpreter.defaultOptions = {
+    execute: true,
+    deferEvents: true,
+    clock: {
+      setTimeout: function (fn, ms) {
+        return setTimeout(fn, ms);
       },
-      logger: global.console.log.bind(console),
-      devTools: false
-    };
-  }(typeof self !== 'undefined' ? self : global);
-
+      clearTimeout: function (id) {
+        return clearTimeout(id);
+      }
+    },
+    logger: /*#__PURE__*/console.log.bind(console),
+    devTools: false
+  };
   Interpreter.interpret = interpret;
   return Interpreter;
 }();

package/es/invokeUtils.js

@@ -1,8 +1,8 @@
 import { __assign, __rest } from './_virtual/_tslib.js';
 import './types.js';
 import { invoke } from './actionTypes.js';
-import './environment.js';
 import './utils.js';
+import './environment.js';
 
 function toInvokeSource(src) {
   if (typeof src === 'string') {
@@ -25,9 +25,9 @@ function toInvokeDefinition(invokeConfig) {
     type: invoke
   }, invokeConfig), {
     toJSON: function () {
-      var onDone = invokeConfig.onDone,
-          onError = invokeConfig.onError,
-          invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
+      invokeConfig.onDone;
+          invokeConfig.onError;
+          var invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
 
       return __assign(__assign({}, invokeDef), {
         type: invoke,

package/es/json.js

@@ -0,0 +1,86 @@
+import { mapValues, isFunction } from './utils.js';
+
+function stringifyFunction(fn) {
+  return {
+    $function: fn.toString()
+  };
+}
+
+function getStateNodeId(stateNode) {
+  return "#".concat(stateNode.id);
+} // derive config from machine
+
+
+function machineToJSON(stateNode) {
+  var config = {
+    type: stateNode.type,
+    initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
+    id: stateNode.id,
+    key: stateNode.key,
+    entry: stateNode.onEntry,
+    exit: stateNode.onExit,
+    on: mapValues(stateNode.on, function (transition) {
+      return transition.map(function (t) {
+        return {
+          target: t.target ? t.target.map(getStateNodeId) : [],
+          source: getStateNodeId(t.source),
+          actions: t.actions,
+          cond: t.cond,
+          eventType: t.eventType
+        };
+      });
+    }),
+    invoke: stateNode.invoke,
+    states: {}
+  };
+  Object.values(stateNode.states).forEach(function (sn) {
+    config.states[sn.key] = machineToJSON(sn);
+  });
+  return config;
+}
+function stringify(machine) {
+  return JSON.stringify(machineToJSON(machine), function (_, value) {
+    if (isFunction(value)) {
+      return {
+        $function: value.toString()
+      };
+    }
+
+    return value;
+  });
+}
+function parse(machineString) {
+  var config = JSON.parse(machineString, function (_, value) {
+    if (typeof value === 'object' && '$function' in value) {
+      return new Function(value.value);
+    }
+
+    return value;
+  });
+  return config;
+}
+function jsonify(value) {
+  Object.defineProperty(value, 'toJSON', {
+    value: function () {
+      return mapValues(value, function (subValue) {
+        if (isFunction(subValue)) {
+          return stringifyFunction(subValue);
+        } else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
+          // mostly for assignments
+          return mapValues(subValue, function (subSubValue) {
+            if (isFunction(subSubValue)) {
+              return stringifyFunction(subSubValue);
+            }
+
+            return subSubValue;
+          });
+        }
+
+        return subValue;
+      });
+    }
+  });
+  return value;
+}
+
+export { jsonify, machineToJSON, parse, stringify, stringifyFunction };

package/es/model.js

@@ -0,0 +1,50 @@
+import { __assign, __spreadArray, __read } from './_virtual/_tslib.js';
+import { assign } from './actions.js';
+import { createMachine } from './Machine.js';
+import { mapValues } from './utils.js';
+
+function createModel(initialContext, creators) {
+  var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
+  var actionCreators = creators === null || creators === void 0 ? void 0 : creators.actions;
+  var model = {
+    initialContext: initialContext,
+    assign: assign,
+    events: eventCreators ? mapValues(eventCreators, function (fn, eventType) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+
+        return __assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), {
+          type: eventType
+        });
+      };
+    }) : undefined,
+    actions: actionCreators ? mapValues(actionCreators, function (fn, actionType) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+
+        return __assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), {
+          type: actionType
+        });
+      };
+    }) : undefined,
+    reset: function () {
+      return assign(initialContext);
+    },
+    createMachine: function (config, implementations) {
+      return createMachine('context' in config ? config : __assign(__assign({}, config), {
+        context: initialContext
+      }), implementations);
+    }
+  };
+  return model;
+}
+
+export { createModel };

package/es/patterns.js

@@ -0,0 +1,48 @@
+import { __assign } from './_virtual/_tslib.js';
+import { toEventObject } from './utils.js';
+
+function toggle(onState, offState, eventType) {
+  var _a, _b, _c;
+
+  return _a = {}, _a[onState] = {
+    on: (_b = {}, _b[eventType] = offState, _b)
+  }, _a[offState] = {
+    on: (_c = {}, _c[eventType] = onState, _c)
+  }, _a;
+}
+var defaultSequencePatternOptions = {
+  nextEvent: 'NEXT',
+  prevEvent: 'PREV'
+};
+function sequence(items, options) {
+  var resolvedOptions = __assign(__assign({}, defaultSequencePatternOptions), options);
+
+  var states = {};
+  var nextEventObject = resolvedOptions.nextEvent === undefined ? undefined : toEventObject(resolvedOptions.nextEvent);
+  var prevEventObject = resolvedOptions.prevEvent === undefined ? undefined : toEventObject(resolvedOptions.prevEvent);
+  items.forEach(function (item, i) {
+    var state = {
+      on: {}
+    };
+
+    if (i + 1 === items.length) {
+      state.type = 'final';
+    }
+
+    if (nextEventObject && i + 1 < items.length) {
+      state.on[nextEventObject.type] = items[i + 1];
+    }
+
+    if (prevEventObject && i > 0) {
+      state.on[prevEventObject.type] = items[i - 1];
+    }
+
+    states[item] = state;
+  });
+  return {
+    initial: items[0],
+    states: states
+  };
+}
+
+export { sequence, toggle };

package/es/stateUtils.js

@@ -7,6 +7,8 @@ var isLeafNode = function (stateNode) {
 function getChildren(stateNode) {
   return Object.keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
+  }).filter(function (sn) {
+    return sn.type !== 'history';
   });
 }
 function getAllStateNodes(stateNode) {
@@ -71,10 +73,6 @@ function getConfiguration(prevStateNodes, stateNodes) {
             for (var _e = (e_3 = void 0, __values(getChildren(s))), _f = _e.next(); !_f.done; _f = _e.next()) {
               var child = _f.value;
 
-              if (child.type === 'history') {
-                continue;
-              }
-
               if (!configuration.has(child)) {
                 configuration.add(child);
 

package/es/typegenTypes.d.ts

@@ -77,21 +77,27 @@ export interface TypegenMeta extends TypegenEnabled {
     eventsCausingServices: Record<string, string>;
 }
 export interface ResolvedTypegenMeta extends TypegenMeta {
-    indexedActions: Record<string, BaseActionObject>;
-    indexedEvents: Record<string, EventObject>;
+    resolved: TypegenMeta & {
+        indexedActions: Record<string, BaseActionObject>;
+        indexedEvents: Record<string, EventObject>;
+    };
 }
 export declare type TypegenConstraint = TypegenEnabled | TypegenDisabled;
-export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
+export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
     [K in keyof TMissingImplementations]: TMissingImplementations[K];
 }>> extends true ? true : false : true;
-export declare type MarkAllImplementationsAsProvided<TResolvedTypesMeta> = TResolvedTypesMeta & {
+interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
         delays: never;
         guards: never;
         services: never;
     };
-};
+}
+export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
+    '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
+    resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
+}
 declare type GenerateServiceEvent<TServiceName, TEventType, TServiceMap extends ServiceMap> = TEventType extends any ? {
     type: TEventType;
 } & Prop<TServiceMap, TServiceName> : never;
@@ -105,17 +111,20 @@ declare type AllowAllEvents = {
     eventsCausingGuards: Record<string, string>;
     eventsCausingServices: Record<string, string>;
 };
-export declare type ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> = TTypesMeta extends TypegenEnabled ? TTypesMeta & {
-    indexedActions: IndexByType<TAction>;
-    indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
-} : MarkAllImplementationsAsProvided<TypegenDisabled> & AllowAllEvents & {
-    indexedActions: IndexByType<TAction>;
-    indexedEvents: Record<string, TEvent> & {
-        __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
-            data: any;
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> {
+    '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
+    resolved: TTypesMeta extends TypegenEnabled ? TTypesMeta & {
+        indexedActions: IndexByType<TAction>;
+        indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+    } : TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
+        indexedActions: IndexByType<TAction>;
+        indexedEvents: Record<string, TEvent> & {
+            __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
+                data: any;
+            };
         };
+        invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
     };
-    invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
-};
+}
 export {};
 //# sourceMappingURL=typegenTypes.d.ts.map

package/es/types.d.ts

@@ -489,16 +489,16 @@ export declare type ActionFunctionMap<TContext, TEvent extends EventObject, TAct
 export declare type DelayFunctionMap<TContext, TEvent extends EventObject> = Record<string, DelayConfig<TContext, TEvent>>;
 export declare type ServiceConfig<TContext, TEvent extends EventObject = AnyEventObject> = string | AnyStateMachine | InvokeCreator<TContext, TEvent>;
 export declare type DelayConfig<TContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
-declare type MachineOptionsActions<TContext, TResolvedTypesMeta, TEventsCausingActions = Prop<TResolvedTypesMeta, 'eventsCausingActions'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TIndexedActions = Prop<TResolvedTypesMeta, 'indexedActions'>> = {
+declare type MachineOptionsActions<TContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>> = {
     [K in keyof TEventsCausingActions]?: ActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>>;
 };
-declare type MachineOptionsDelays<TContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<TResolvedTypesMeta, 'eventsCausingDelays'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+declare type MachineOptionsDelays<TContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
     [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
 };
-declare type MachineOptionsGuards<TContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<TResolvedTypesMeta, 'eventsCausingGuards'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+declare type MachineOptionsGuards<TContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
     [K in keyof TEventsCausingGuards]?: ConditionPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
 };
-declare type MachineOptionsServices<TContext, TResolvedTypesMeta, TEventsCausingServices = Prop<TResolvedTypesMeta, 'eventsCausingServices'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TInvokeSrcNameMap = Prop<TResolvedTypesMeta, 'invokeSrcNameMap'>> = {
+declare type MachineOptionsServices<TContext, TResolvedTypesMeta, TEventsCausingServices = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingServices'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
     [K in keyof TEventsCausingServices]?: AnyStateMachine | InvokeCreator<TContext, Cast<Prop<TIndexedEvents, TEventsCausingServices[K]>, EventObject>, Prop<Prop<TIndexedEvents, Prop<TInvokeSrcNameMap, K>>, 'data'>, EventObject, Cast<TIndexedEvents[keyof TIndexedEvents], EventObject>>;
 };
 declare type MakeKeysRequired<T extends string> = {
@@ -519,14 +519,14 @@ declare type GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMiss
 declare type GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'services', Prop<TMissingImplementations, 'services'>, TRequireMissingImplementations> & {
     services?: MachineOptionsServices<TContext, TResolvedTypesMeta>;
 };
-export declare type InternalMachineOptions<TContext, TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & {
+export declare type InternalMachineOptions<TContext, TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & {
     /**
      * @deprecated Use `services` instead.
      */
     activities?: Record<string, ActivityConfig<TContext, TEvent>>;
 };
 export declare type MachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>;
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<NoInfer<TContext>, TStateSchema, TEvent, TAction> {
+export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<NoInfer<TContext>, TStateSchema, NoInfer<TEvent>, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -572,7 +572,7 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, TEvent, TAction, TServiceMap>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
+}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TServiceMap>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
     id: string;
     states: StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta>['states'];
     withConfig(options: InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, TServiceMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
@@ -1011,9 +1011,9 @@ export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventOb
      */
     state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
 };
-export declare type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : R extends Promise<infer U> ? ActorRef<never, U> : R extends Behavior<infer TEvent, infer TEmitted> ? ActorRef<TEvent, TEmitted> : never : never;
+export declare type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta> : R extends Promise<infer U> ? ActorRef<never, U> : R extends Behavior<infer TEvent, infer TEmitted> ? ActorRef<TEvent, TEmitted> : never : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any, any>;
-export declare type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : never;
+export declare type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta> : never;
 export declare type MachineOptionsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, any, infer TEvent, any, any, any, infer TResolvedTypesMeta> ? InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export declare type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
 export interface ActorContext<TEvent extends EventObject, TEmitted> {

package/es/utils.js

@@ -1,8 +1,11 @@
-import { __assign, __spreadArray, __read, __values } from './_virtual/_tslib.js';
+import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
 import { DEFAULT_GUARD_TYPE, TARGETLESS_KEY, STATE_DELIMITER } from './constants.js';
 import { IS_PRODUCTION } from './environment.js';
 
 var _a;
+function keys(value) {
+  return Object.keys(value);
+}
 function matchesState(parentStateId, childStateId, delimiter) {
   if (delimiter === void 0) {
     delimiter = STATE_DELIMITER;
@@ -39,6 +42,13 @@ function getEventType(event) {
     throw new Error('Events must be strings or objects with a string event.type property.');
   }
 }
+function getActionType(action) {
+  try {
+    return isString(action) || typeof action === 'number' ? "".concat(action) : isFunction(action) ? action.name : action.type;
+  } catch (e) {
+    throw new Error('Actions must be strings or objects with a string action.type property.');
+  }
+}
 function toStatePath(stateId, delimiter) {
   try {
     if (isArray(stateId)) {
@@ -213,6 +223,46 @@ function toStatePaths(stateValue) {
   }));
   return result;
 }
+function pathsToStateValue(paths) {
+  var e_4, _a;
+
+  var result = {};
+
+  if (paths && paths.length === 1 && paths[0].length === 1) {
+    return paths[0][0];
+  }
+
+  try {
+    for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+      var currentPath = paths_1_1.value;
+      var marker = result; // tslint:disable-next-line:prefer-for-of
+
+      for (var i = 0; i < currentPath.length; i++) {
+        var subPath = currentPath[i];
+
+        if (i === currentPath.length - 2) {
+          marker[subPath] = currentPath[i + 1];
+          break;
+        }
+
+        marker[subPath] = marker[subPath] || {};
+        marker = marker[subPath];
+      }
+    }
+  } catch (e_4_1) {
+    e_4 = {
+      error: e_4_1
+    };
+  } finally {
+    try {
+      if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+    } finally {
+      if (e_4) throw e_4.error;
+    }
+  }
+
+  return result;
+}
 function flatten(array) {
   var _a;
 
@@ -573,4 +623,4 @@ function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
 
-export { createInvokeId, evaluateGuard, flatten, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };
+export { createInvokeId, evaluateGuard, flatten, getActionType, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, pathsToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

package/es/waitFor.d.ts

@@ -0,0 +1,32 @@
+import { ActorRef, EmittedFrom } 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.
+ *
+ * @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: EmittedFrom<TActorRef>) => boolean, options?: Partial<WaitForOptions>): Promise<EmittedFrom<TActorRef>>;
+export {};
+//# sourceMappingURL=waitFor.d.ts.map