xstate 4.30.6 → 4.32.1

package/es/waitFor.js

@@ -0,0 +1,71 @@
+import { __assign } from './_virtual/_tslib.js';
+
+var defaultWaitForOptions = {
+  timeout: 10000 // 10 seconds
+
+};
+/**
+ * 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
+ */
+
+function waitFor(actorRef, predicate, options) {
+  var resolvedOptions = __assign(__assign({}, defaultWaitForOptions), options);
+
+  return new Promise(function (res, rej) {
+    var done = false;
+
+    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+
+    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
+      sub.unsubscribe();
+      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+    }, resolvedOptions.timeout);
+
+    var dispose = function () {
+      clearTimeout(handle);
+      done = true;
+      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+    };
+
+    var sub = actorRef.subscribe({
+      next: function (emitted) {
+        if (predicate(emitted)) {
+          dispose();
+          res(emitted);
+        }
+      },
+      error: function (err) {
+        dispose();
+        rej(err);
+      },
+      complete: function () {
+        dispose();
+        rej(new Error("Actor terminated without satisfying predicate"));
+      }
+    });
+
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
+export { waitFor };

package/lib/State.d.ts

@@ -91,14 +91,14 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "machine" | "tags" | "transitions" | "configuration"> & {
+    toJSON(): Omit<this, "machine" | "configuration" | "transitions" | "tags"> & {
         tags: string[];
     };
     /**
      * Whether the current state value is a subset of the given parent state value.
      * @param parentStateValue
      */
-    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'matchesStates'> : never>(parentStateValue: TSV): boolean;
+    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : never>(parentStateValue: TSV): boolean;
     matches<TSV extends TResolvedTypesMeta extends TypegenDisabled ? TTypestate['value'] : never>(parentStateValue: TSV): this is State<(TTypestate extends any ? {
         value: TSV;
         context: any;
@@ -109,7 +109,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * Whether the current state configuration has a state node with the specified `tag`.
      * @param tag
      */
-    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'tags'> : string): boolean;
+    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'tags'> : string): boolean;
     /**
      * Determines whether sending the `event` will cause a non-forbidden transition
      * to be selected, even if the transitions have no actions nor

package/lib/StateNode.js

@@ -924,7 +924,7 @@ function () {
       transitions: stateTransition.transitions,
       children: children,
       done: isDone,
-      tags: currentState === null || currentState === void 0 ? void 0 : currentState.tags,
+      tags: stateUtils.getTagsFromConfiguration(resolvedConfiguration),
       machine: this
     });
     var didUpdateContext = context !== updatedContext;
@@ -974,7 +974,6 @@ function () {
     maybeNextState.changed = changed; // Preserve original history after raised events
 
     maybeNextState.history = history;
-    maybeNextState.tags = stateUtils.getTagsFromConfiguration(maybeNextState.configuration);
     return maybeNextState;
   };
   /**

package/lib/actions.d.ts

@@ -1,4 +1,4 @@
-import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, ActorRef, EventFrom } from './types';
+import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, EventFrom, AnyActorRef } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
@@ -52,7 +52,7 @@ declare type InferEvent<E extends EventObject> = {
  * @param options Send action options
  * @returns An XState send action object
  */
-export declare function sendTo<TContext, TEvent extends EventObject, TActor extends ActorRef<EventObject>>(actor: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
+export declare function sendTo<TContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
 /**
  * Sends an update event to this machine's parent.
  */

package/lib/interpreter.js

@@ -48,7 +48,6 @@ function () {
     }
 
     this.machine = machine;
-    this.scheduler = new scheduler.Scheduler();
     this.delayedEventsMap = {};
     this.listeners = new Set();
     this.contextListeners = new Set();
@@ -365,12 +364,16 @@ function () {
 
     this.listeners.add(listener); // Send current state to listener
 
-    if (this.status === exports.InterpreterStatus.Running) {
+    if (this.status !== exports.InterpreterStatus.NotStarted) {
       listener(this.state);
     }
 
     if (resolvedCompleteListener) {
-      this.onDone(resolvedCompleteListener);
+      if (this.status === exports.InterpreterStatus.Stopped) {
+        resolvedCompleteListener();
+      } else {
+        this.onDone(resolvedCompleteListener);
+      }
     }
 
     return {
@@ -598,6 +601,7 @@ function () {
         child.stop();
       }
     });
+    this.children.clear();
 
     try {
       // Cancel all delayed events
@@ -618,8 +622,12 @@ function () {
     }
 
     this.scheduler.clear();
+    this.scheduler = new scheduler.Scheduler({
+      deferEvents: this.options.deferEvents
+    });
     this.initialized = false;
     this.status = exports.InterpreterStatus.Stopped;
+    this._initialState = undefined;
     registry.registry.free(this.sessionId);
     return this;
   };

package/lib/model.types.d.ts

@@ -1,8 +1,11 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
+import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
 import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
+declare type SimplisticExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
+    type: TEventType;
+} ? TEvent : never;
 export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
     initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
     reset: () => AssignAction<TContext, any>;
@@ -49,4 +52,5 @@ export interface FinalModelCreators<Self> {
 export declare type UnionFromCreatorsReturnTypes<TCreators> = {
     [K in keyof TCreators]: TCreators[K] extends AnyFunction ? ReturnType<TCreators[K]> : never;
 }[keyof TCreators];
+export {};
 //# sourceMappingURL=model.types.d.ts.map

package/lib/stateUtils.js

@@ -11,6 +11,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) {
@@ -75,10 +77,6 @@ function getConfiguration(prevStateNodes, stateNodes) {
             for (var _e = (e_3 = void 0, _tslib.__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/lib/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,23 @@ 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: {
+        enabled: TTypesMeta & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
         };
-    };
-    invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
-};
+        disabled: 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__'>;
+        };
+    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
+}
 export {};
 //# sourceMappingURL=typegenTypes.d.ts.map

package/lib/types.d.ts

@@ -2,7 +2,7 @@ import { Clock, Interpreter } from './interpreter';
 import { Model } from './model.types';
 import { State } from './State';
 import { StateNode } from './StateNode';
-import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided, TypegenEnabled } from './typegenTypes';
 export declare type AnyFunction = (...args: any[]) => any;
 declare type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export declare type IsNever<T> = [T] extends [never] ? true : false;
@@ -15,9 +15,7 @@ export declare type Merge<M, N> = Omit<M, keyof N> & N;
 export declare type IndexByType<T extends {
     type: string;
 }> = {
-    [K in T['type']]: Extract<T, {
-        type: K;
-    }>;
+    [K in T['type']]: T extends any ? (K extends T['type'] ? T : never) : never;
 };
 export declare type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export declare type IsAny<T> = Equals<T, any>;
@@ -241,13 +239,7 @@ export declare type StatesDefinition<TContext, TStateSchema extends StateSchema,
 export declare type TransitionConfigTarget<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
 export declare type TransitionConfigOrTarget<TContext, TEvent extends EventObject> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>;
 export declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
-    [K in TEvent['type']]?: TransitionConfigOrTarget<TContext, TEvent extends {
-        type: K;
-    } ? TEvent : never>;
-} & {
-    ''?: TransitionConfigOrTarget<TContext, TEvent>;
-} & {
-    '*'?: TransitionConfigOrTarget<TContext, TEvent>;
+    [K in TEvent['type'] | '' | '*']?: K extends '' | '*' ? TransitionConfigOrTarget<TContext, TEvent> : TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>>;
 };
 declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<(TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & {
     event: TEvent['type'];
@@ -489,16 +481,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,7 +511,7 @@ 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.
      */
@@ -988,9 +980,7 @@ export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
 export declare type Spawnable = AnyStateMachine | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | Behavior<any>;
-export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
-    type: TEventType;
-} ? TEvent : never;
+export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends any ? TEventType extends TEvent['type'] ? TEvent : never : never;
 export interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
 }
@@ -1001,6 +991,7 @@ export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Su
     stop?: () => void;
     toJSON?: () => any;
 }
+export declare type AnyActorRef = ActorRef<any, any>;
 /**
  * @deprecated Use `ActorRef` instead.
  */
@@ -1011,9 +1002,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, MarkAllImplementationsAsProvided<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)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, MarkAllImplementationsAsProvided<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> {
@@ -1027,11 +1018,14 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     initialState: TEmitted;
     start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
 }
-export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
+export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends Interpreter<infer _, infer __, infer ___, infer ____, infer _____> ? R['initialState'] : R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
 declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ___, infer ____, infer _____, infer ______> ? TEvent : R extends Model<infer _, infer TEvent, infer __, infer ___> ? TEvent : R extends State<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ___, infer ____> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
-export declare type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : Extract<TEvent, {
-    type: K;
-}>;
+export declare type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
 export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____, infer _____, infer ______> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : never : never;
+declare type Matches<TypegenEnabledArg, TypegenDisabledArg> = {
+    (stateValue: TypegenEnabledArg): any;
+    (stateValue: TypegenDisabledArg): any;
+};
+export declare type StateValueFrom<TMachine extends AnyStateMachine> = StateFrom<TMachine>['matches'] extends Matches<infer TypegenEnabledArg, infer TypegenDisabledArg> ? TMachine['__TResolvedTypesMeta'] extends TypegenEnabled ? TypegenEnabledArg : TypegenDisabledArg : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/lib/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

package/lib/waitFor.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+
+var defaultWaitForOptions = {
+  timeout: 10000 // 10 seconds
+
+};
+/**
+ * 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
+ */
+
+function waitFor(actorRef, predicate, options) {
+  var resolvedOptions = _tslib.__assign(_tslib.__assign({}, defaultWaitForOptions), options);
+
+  return new Promise(function (res, rej) {
+    var done = false;
+
+    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+
+    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
+      sub.unsubscribe();
+      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+    }, resolvedOptions.timeout);
+
+    var dispose = function () {
+      clearTimeout(handle);
+      done = true;
+      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+    };
+
+    var sub = actorRef.subscribe({
+      next: function (emitted) {
+        if (predicate(emitted)) {
+          dispose();
+          res(emitted);
+        }
+      },
+      error: function (err) {
+        dispose();
+        rej(err);
+      },
+      complete: function () {
+        dispose();
+        rej(new Error("Actor terminated without satisfying predicate"));
+      }
+    });
+
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
+exports.waitFor = waitFor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.30.6",
+  "version": "4.32.1",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",