xstate 4.30.5 → 4.32.0

package/es/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,14 +511,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 +564,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>;
@@ -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, 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> {
@@ -1029,9 +1020,12 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
 }
 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;
 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/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

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

@@ -447,7 +447,8 @@ function () {
       value: this.resolve(stateFromConfig.value),
       configuration: configuration,
       done: stateUtils.isInFinalState(configuration, this),
-      tags: stateUtils.getTagsFromConfiguration(configuration)
+      tags: stateUtils.getTagsFromConfiguration(configuration),
+      machine: this.machine
     }));
   };
 
@@ -923,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;
@@ -973,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/devTools.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+var environment = require('./environment.js');
+
 function getGlobal() {
   if (typeof globalThis !== 'undefined') {
     return globalThis;
@@ -20,7 +21,9 @@ function getGlobal() {
     return global;
   }
 
-  return undefined;
+  if (!environment.IS_PRODUCTION) {
+    console.warn('XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues');
+  }
 }
 
 function getDevTools() {

package/lib/interpreter.d.ts

@@ -23,7 +23,6 @@ export declare enum InterpreterStatus {
     Running = 1,
     Stopped = 2
 }
-/** @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 */
 export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -190,8 +189,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     toJSON(): {
         id: string;
     };
-    /** @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 */
-    [symbolObservable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
+    [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
     getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
 }
 export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;

package/lib/interpreter.js

@@ -28,8 +28,6 @@ exports.InterpreterStatus = void 0;
   InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
   InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
 })(exports.InterpreterStatus || (exports.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__*/
@@ -50,7 +48,6 @@ function () {
     }
 
     this.machine = machine;
-    this.scheduler = new scheduler.Scheduler();
     this.delayedEventsMap = {};
     this.listeners = new Set();
     this.contextListeners = new Set();
@@ -367,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 {
@@ -459,7 +460,13 @@ function () {
     if (this.status === exports.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.registry.register(this.sessionId, this);
     this.initialized = true;
@@ -594,6 +601,7 @@ function () {
         child.stop();
       }
     });
+    this.children.clear();
 
     try {
       // Cancel all delayed events
@@ -614,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;
   };
@@ -1314,8 +1326,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[utils.symbolObservable] = function () {
     return this;
@@ -1336,23 +1346,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/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