xstate 4.31.0 → 4.33.0

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.d.ts

@@ -3,6 +3,7 @@ import { StateNode } from './StateNode';
 declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
 declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
 export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any, any>) => boolean;
+export declare function getAllChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
 export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
 export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any, any>): Array<StateNode<TC, any, TE, any, any, any>>;
 export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>): Set<StateNode<TC, any, TE, any, any, any>>;

package/lib/stateUtils.js

@@ -8,10 +8,13 @@ var utils = require('./utils.js');
 var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
 };
-function getChildren(stateNode) {
+function getAllChildren(stateNode) {
   return Object.keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
-  }).filter(function (sn) {
+  });
+}
+function getChildren(stateNode) {
+  return getAllChildren(stateNode).filter(function (sn) {
     return sn.type !== 'history';
   });
 }
@@ -261,6 +264,7 @@ function getTagsFromConfiguration(configuration) {
 }
 
 exports.getAdjList = getAdjList;
+exports.getAllChildren = getAllChildren;
 exports.getAllStateNodes = getAllStateNodes;
 exports.getChildren = getChildren;
 exports.getConfiguration = getConfiguration;

package/lib/typegenTypes.d.ts

@@ -113,18 +113,21 @@ declare type AllowAllEvents = {
 };
 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;
+    resolved: {
+        enabled: TTypesMeta & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+        };
+        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__'>;
         };
-        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'];
@@ -430,6 +422,12 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      * @default false
      */
     preserveActionOrder?: boolean;
+    /**
+     * Whether XState calls actions with the event directly responsible for the related transition.
+     *
+     * @default false
+     */
+    predictableActionArguments?: boolean;
     /**
      * A text description of the state node
      */
@@ -864,6 +862,9 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
      */
     activities?: ActivityMap;
     meta?: any;
+    /**
+     * @deprecated
+     */
     events?: TEvent[];
     configuration: Array<StateNode<TContext, any, TEvent>>;
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
@@ -988,9 +989,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 +1000,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.
  */
@@ -1027,11 +1027,15 @@ 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 declare type PredictableActionArgumentsExec = (action: ActionObject<unknown, EventObject>, context: unknown, _event: SCXML.Event<EventObject>) => void;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/lib/utils.d.ts

@@ -67,6 +67,6 @@ export declare function normalizeTarget<TContext, TEvent extends EventObject>(ta
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
 export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
 export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
-export declare function toObserver<T>(nextHandler: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
+export declare function toObserver<T>(nextHandler?: Partial<Observer<T>> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
 //# sourceMappingURL=utils.d.ts.map

package/lib/utils.js

@@ -609,18 +609,14 @@ function toInvokeSource(src) {
   return src;
 }
 function toObserver(nextHandler, errorHandler, completionHandler) {
-  if (typeof nextHandler === 'object') {
-    return nextHandler;
-  }
-
-  var noop = function () {
-    return void 0;
-  };
+  var noop = function () {};
 
+  var isObserver = typeof nextHandler === 'object';
+  var self = isObserver ? nextHandler : null;
   return {
-    next: nextHandler,
-    error: errorHandler || noop,
-    complete: completionHandler || noop
+    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
+    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
+    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
   };
 }
 function createInvokeId(stateNodeId, index) {

package/lib/waitFor.js

@@ -33,7 +33,12 @@ function waitFor(actorRef, predicate, options) {
 
   return new Promise(function (res, rej) {
     var done = false;
-    var handle = setTimeout(function () {
+
+    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);

package/package.json

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