xstate 4.27.0-pr2674-2021926101023 → 4.29.0

package/es/types.d.ts

@@ -2,11 +2,10 @@ import { Clock, Interpreter } from './interpreter';
 import { Model } from './model.types';
 import { State } from './State';
 import { StateNode } from './StateNode';
-import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint } from './typegenTypes';
+import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided } 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;
-export declare type Cast<T extends any, TCastType extends any> = T extends TCastType ? T : TCastType;
 export declare type Compute<A extends any> = {
     [K in keyof A]: A[K];
 } & unknown;
@@ -20,6 +19,9 @@ export declare type IndexByType<T extends {
         type: K;
     }>;
 };
+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>;
+export declare type Cast<A, B> = A extends B ? A : B;
 export declare type EventType = string;
 export declare type ActionType = string;
 export declare type MetaObject = Record<string, any>;
@@ -50,7 +52,7 @@ export interface ActionObject<TContext, TEvent extends EventObject> extends Base
     /**
      * The implementation for executing the action.
      */
-    exec?: ActionFunction<TContext, TEvent>;
+    exec?: ActionFunction<TContext, TEvent> | undefined;
 }
 export declare type DefaultContext = Record<string, any> | undefined;
 export declare type EventData = Record<string, any> & {
@@ -99,14 +101,6 @@ export interface StateValueMap {
  * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
  */
 export declare type StateValue = string | StateValueMap;
-declare type KeysWithStates<TStates extends Record<string, StateSchema> | undefined> = TStates extends object ? {
-    [K in keyof TStates]-?: TStates[K] extends {
-        states: object;
-    } ? K : never;
-}[keyof TStates] : never;
-export declare type ExtractStateValue<TSchema extends Required<Pick<StateSchema<any>, 'states'>>> = keyof TSchema['states'] | (KeysWithStates<TSchema['states']> extends never ? never : {
-    [K in KeysWithStates<TSchema['states']>]?: ExtractStateValue<TSchema['states'][K]>;
-});
 export interface HistoryValue {
     states: Record<string, HistoryValue | undefined>;
     current: StateValue | undefined;
@@ -132,7 +126,7 @@ export interface TransitionConfig<TContext, TEvent extends EventObject> {
     actions?: Actions<TContext, TEvent>;
     in?: StateValue;
     internal?: boolean;
-    target?: TransitionTarget<TContext, TEvent>;
+    target?: TransitionTarget<TContext, TEvent> | undefined;
     meta?: Record<string, any>;
     description?: string;
 }
@@ -171,7 +165,9 @@ export interface PayloadSender<TEvent extends EventObject> {
      */
     <K extends TEvent['type']>(eventType: K, payload: NeverIfEmpty<ExtractExtraParameters<TEvent, K>>): void;
 }
-export declare type Receiver<TEvent extends EventObject> = (listener: (event: TEvent) => void) => void;
+export declare type Receiver<TEvent extends EventObject> = (listener: {
+    bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
 export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (callback: Sender<TSentEvent>, onReceive: Receiver<TEvent>) => (() => void) | Promise<any> | void;
 export interface InvokeMeta {
     data: any;
@@ -191,7 +187,8 @@ export interface InvokeMeta {
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TEvent extends EventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, TEvent> | Behavior<any>;
+export declare type InvokeCreator<TContext, TSourceEvent extends EventObject, TFinalContext = any, TInputEvent extends EventObject = any, // keeping a slot for it here, but it's actually not used right now to ensure that the communication contract between actors is satisfied
+TOutputEvent extends EventObject = TSourceEvent> = (context: TContext, event: TSourceEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any, any, any, any, any> | Subscribable<EventObject> | InvokeCallback<TInputEvent, TOutputEvent> | Behavior<any>;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
@@ -371,7 +368,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      *
      * This is equivalent to defining a `[done(id)]` transition on this state node's `on` property.
      */
-    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneEventObject>>;
+    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneEventObject>> | undefined;
     /**
      * The mapping (or array) of delays (in milliseconds) to their potential transition(s).
      * The delayed transitions are taken after the specified delay in an interpreter.
@@ -498,7 +495,7 @@ declare type MachineOptionsGuards<TContext, TResolvedTypesMeta, TEventsCausingGu
     [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'>> = {
-    [K in keyof TEventsCausingServices]?: StateMachine<any, any, any> | InvokeCreator<TContext, Cast<Prop<TIndexedEvents, TEventsCausingServices[K]>, EventObject>, Prop<Prop<TIndexedEvents, Prop<TInvokeSrcNameMap, K>>, 'data'>>;
+    [K in keyof TEventsCausingServices]?: StateMachine<any, any, any, any, any, any, any> | 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> = {
     [K in T]: unknown;
@@ -524,8 +521,8 @@ export declare type InternalMachineOptions<TContext, TEvent extends EventObject,
      */
     activities?: Record<string, ActivityConfig<TContext, TEvent>>;
 };
-export declare type MachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>;
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TTypesMeta = TypegenDisabled> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
+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<TContext, TStateSchema, TEvent, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -534,10 +531,13 @@ export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEven
      * The machine's own version.
      */
     version?: string;
-    schema?: MachineSchema<TContext, TEvent>;
-    tsTypes?: TTypesMeta | true;
+    schema?: MachineSchema<TContext, TEvent, TServiceMap>;
+    tsTypes?: TTypesMeta;
 }
-export interface MachineSchema<TContext, TEvent extends EventObject> {
+export declare type ServiceMap = Record<string, {
+    data: any;
+}>;
+export interface MachineSchema<TContext, TEvent extends EventObject, TServiceMap extends ServiceMap = ServiceMap> {
     context?: TContext;
     events?: TEvent;
     actions?: {
@@ -548,10 +548,7 @@ export interface MachineSchema<TContext, TEvent extends EventObject> {
         type: string;
         [key: string]: any;
     };
-    services?: {
-        type: string;
-        [key: string]: any;
-    };
+    services?: TServiceMap;
 }
 export interface StandardMachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> extends StateNodeConfig<TContext, TStateSchema, TEvent> {
 }
@@ -570,19 +567,20 @@ 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, TResolvedTypesMeta = TypegenDisabled> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> {
+}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = TypegenDisabled> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
     id: string;
-    states: StateNode<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>['states'];
-    withConfig(options: InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, MarkAllImplementationsAsProvided<TResolvedTypesMeta>>;
-    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>;
+    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>;
+    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, TServiceMap, TResolvedTypesMeta>;
     __TContext: TContext;
     __TStateSchema: TStateSchema;
     __TEvent: TEvent;
     __TTypestate: TTypestate;
     __TAction: TAction;
+    __TServiceMap: TServiceMap;
     __TResolvedTypesMeta: TResolvedTypesMeta;
 }
-export declare type StateFrom<T extends StateMachine<any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any>)> = T extends StateMachine<any, any, any, any, any, any> ? ReturnType<T['transition']> : T extends (...args: any[]) => StateMachine<any, any, any, any, any, any> ? ReturnType<ReturnType<T>['transition']> : never;
+export declare type StateFrom<T extends StateMachine<any, any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any, any>)> = T extends StateMachine<any, any, any, any, any, any, any> ? ReturnType<T['transition']> : T extends (...args: any[]) => StateMachine<any, any, any, any, any, any, any> ? ReturnType<ReturnType<T>['transition']> : never;
 export interface ActionMap<TContext, TEvent extends EventObject> {
     onEntry: Array<Action<TContext, TEvent>>;
     actions: Array<Action<TContext, TEvent>>;
@@ -601,9 +599,9 @@ export interface ActivityMap {
 }
 export interface StateTransition<TContext, TEvent extends EventObject> {
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    configuration: Array<StateNode<TContext, any, TEvent, any, any>>;
-    entrySet: Array<StateNode<TContext, any, TEvent, any, any>>;
-    exitSet: Array<StateNode<TContext, any, TEvent, any, any>>;
+    configuration: Array<StateNode<TContext, any, TEvent, any, any, any>>;
+    entrySet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
+    exitSet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     /**
      * The source state that preceded the transition.
      */
@@ -860,7 +858,7 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     tags?: Set<string>;
-    machine?: StateMachine<TContext, any, TEvent, any, any, any>;
+    machine?: StateMachine<TContext, any, TEvent, any, any, any, any>;
 }
 export interface StateSchema<TC = any> {
     meta?: any;
@@ -966,18 +964,21 @@ export interface Observer<T> {
 export interface Subscription {
     unsubscribe(): void;
 }
+export interface InteropObservable<T> {
+    [Symbol.observable]: () => Subscribable<T>;
+}
 export interface Subscribable<T> {
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
     subscribe(observer: Observer<T>): Subscription;
 }
-export declare type Spawnable = StateMachine<any, any, any> | PromiseLike<any> | InvokeCallback | Subscribable<any> | Behavior<any>;
+export declare type Spawnable = StateMachine<any, any, any> | 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 interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
 }
-export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Subscribable<TEmitted> {
+export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Subscribable<TEmitted>, InteropObservable<TEmitted> {
     send: Sender<TEvent>;
     id: string;
     getSnapshot: () => TEmitted | undefined;
@@ -994,11 +995,11 @@ export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventOb
      */
     state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
 };
-export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
+export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, any> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any, any>;
-export declare type InterpreterFrom<T extends StateMachine<any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any>)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : never;
-export declare type MachineOptionsFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, any, infer TEvent, any, any, infer TResolvedTypesMeta> ? InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
-export declare type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
+export declare type InterpreterFrom<T extends StateMachine<any, any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any, any>)> = 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 MachineOptionsFrom<T extends StateMachine<any, any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any, any>), 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> {
     parent?: ActorRef<any, any>;
     self: ActorRef<TEvent, TEmitted>;
@@ -1011,7 +1012,7 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     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;
-declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ____> ? TEvent : never : never;
+declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, 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;
 }>;

package/es/utils.d.ts

@@ -52,7 +52,11 @@ export declare function isFunction(value: any): value is Function;
 export declare function isString(value: any): value is string;
 export declare function toGuard<TContext, TEvent extends EventObject>(condition?: Condition<TContext, TEvent>, guardMap?: Record<string, ConditionPredicate<TContext, TEvent>>): Guard<TContext, TEvent> | undefined;
 export declare function isObservable<T>(value: any): value is Subscribable<T>;
-export declare const symbolObservable: any;
+export declare const symbolObservable: string | typeof Symbol.observable;
+export declare const interopSymbols: {
+    [x: string]: () => any;
+    [Symbol.observable]: () => any;
+};
 export declare function isMachine(value: any): value is StateMachine<any, any, any>;
 export declare function isActor(value: any): value is Actor;
 export declare const uniqueId: () => string;
@@ -66,4 +70,5 @@ export declare function reportUnhandledExceptionOnInvocation(originalError: any,
 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 createInvokeId(stateNodeId: string, index: number): string;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -2,6 +2,7 @@ import { __spreadArray, __read, __values, __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);
 }
@@ -36,7 +37,7 @@ function matchesState(parentStateId, childStateId, delimiter) {
 }
 function getEventType(event) {
   try {
-    return isString(event) || typeof event === 'number' ? "" + event : event.type;
+    return isString(event) || typeof event === 'number' ? "".concat(event) : event.type;
   } catch (e) {
     throw new Error('Events must be strings or objects with a string event.type property.');
   }
@@ -49,7 +50,7 @@ function toStatePath(stateId, delimiter) {
 
     return stateId.toString().split(delimiter);
   } catch (e) {
-    throw new Error("'" + stateId + "' is not a valid state path.");
+    throw new Error("'".concat(stateId, "' is not a valid state path."));
   }
 }
 function isStateLike(state) {
@@ -218,7 +219,7 @@ function toStatePaths(stateValue) {
 function flatten(array) {
   var _a;
 
-  return (_a = []).concat.apply(_a, __spreadArray([], __read(array)));
+  return (_a = []).concat.apply(_a, __spreadArray([], __read(array), false));
 }
 function toArrayStrict(value) {
   if (isArray(value)) {
@@ -395,7 +396,7 @@ if (!IS_PRODUCTION) {
     }
 
     if (console !== undefined) {
-      var args = ["Warning: " + message];
+      var args = ["Warning: ".concat(message)];
 
       if (error) {
         args.push(error);
@@ -460,6 +461,9 @@ function isObservable(value) {
 var symbolObservable = /*#__PURE__*/function () {
   return typeof Symbol === 'function' && Symbol.observable || '@@observable';
 }();
+var interopSymbols = (_a = {}, _a[symbolObservable] = function () {
+  return this;
+}, _a);
 function isMachine(value) {
   try {
     return '__xstatenode' in value;
@@ -524,15 +528,15 @@ function normalizeTarget(target) {
 }
 function reportUnhandledExceptionOnInvocation(originalError, currentError, id) {
   if (!IS_PRODUCTION) {
-    var originalStackTrace = originalError.stack ? " Stacktrace was '" + originalError.stack + "'" : '';
+    var originalStackTrace = originalError.stack ? " Stacktrace was '".concat(originalError.stack, "'") : '';
 
     if (originalError === currentError) {
       // tslint:disable-next-line:no-console
-      console.error("Missing onError handler for invocation '" + id + "', error was '" + originalError + "'." + originalStackTrace);
+      console.error("Missing onError handler for invocation '".concat(id, "', error was '").concat(originalError, "'.").concat(originalStackTrace));
     } else {
-      var stackTrace = currentError.stack ? " Stacktrace was '" + currentError.stack + "'" : ''; // tslint:disable-next-line:no-console
+      var stackTrace = currentError.stack ? " Stacktrace was '".concat(currentError.stack, "'") : ''; // tslint:disable-next-line:no-console
 
-      console.error("Missing onError handler and/or unhandled exception/promise rejection for invocation '" + id + "'. " + ("Original error: '" + originalError + "'. " + originalStackTrace + " Current error is '" + currentError + "'." + stackTrace));
+      console.error("Missing onError handler and/or unhandled exception/promise rejection for invocation '".concat(id, "'. ") + "Original error: '".concat(originalError, "'. ").concat(originalStackTrace, " Current error is '").concat(currentError, "'.").concat(stackTrace));
     }
   }
 }
@@ -551,7 +555,7 @@ function evaluateGuard(machine, guard, context, _event, state) {
   var condFn = guards === null || guards === void 0 ? void 0 : guards[guard.type];
 
   if (!condFn) {
-    throw new Error("Guard '" + guard.type + "' is not implemented on machine '" + machine.id + "'.");
+    throw new Error("Guard '".concat(guard.type, "' is not implemented on machine '").concat(machine.id, "'."));
   }
 
   return condFn(context, _event.data, guardMeta);
@@ -580,5 +584,8 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
     complete: completionHandler || noop
   };
 }
+function createInvokeId(stateNodeId, index) {
+  return "".concat(stateNodeId, ":invocation[").concat(index, "]");
+}
 
-export { evaluateGuard, flatten, getEventType, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, 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, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, 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 };

package/lib/Actor.js

@@ -7,7 +7,7 @@ var utils = require('./utils.js');
 var serviceScope = require('./serviceScope.js');
 
 function createNullActor(id) {
-  return {
+  return _tslib.__assign({
     id: id,
     send: function () {
       return void 0;
@@ -27,7 +27,7 @@ function createNullActor(id) {
         id: id
       };
     }
-  };
+  }, utils.interopSymbols);
 }
 /**
  * Creates a deferred actor that is able to be invoked given the provided
@@ -76,7 +76,7 @@ function isSpawnedActor(item) {
   return isActor(item) && 'id' in item;
 }
 function toActorRef(actorRefLike) {
-  return _tslib.__assign({
+  return _tslib.__assign(_tslib.__assign({
     subscribe: function () {
       return {
         unsubscribe: function () {
@@ -88,7 +88,7 @@ function toActorRef(actorRefLike) {
     getSnapshot: function () {
       return undefined;
     }
-  }, actorRefLike);
+  }, utils.interopSymbols), actorRefLike);
 }
 
 exports.createDeferredActor = createDeferredActor;

package/lib/Machine.d.ts

@@ -1,13 +1,13 @@
 import { Model } from './model.types';
-import { AnyEventObject, BaseActionObject, DefaultContext, EventObject, MachineConfig, MachineOptions, InternalMachineOptions, StateMachine, StateSchema, Typestate } from './types';
+import { AnyEventObject, BaseActionObject, DefaultContext, EventObject, MachineConfig, InternalMachineOptions, StateMachine, StateSchema, Typestate, ServiceMap } from './types';
 import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes';
 /**
  * @deprecated Use `createMachine(...)` instead.
  */
-export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: MachineOptions<TContext, TEvent>, initialContext?: TContext): StateMachine<TContext, any, TEvent>;
-export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: MachineOptions<TContext, TEvent>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent>;
+export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TypegenDisabled, TEvent, BaseActionObject, ServiceMap>>, initialContext?: TContext): StateMachine<TContext, any, TEvent, any, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, TEvent, BaseActionObject, ServiceMap>>;
+export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TypegenDisabled, TEvent, BaseActionObject, ServiceMap>>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent, any, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, TEvent, BaseActionObject, ServiceMap>>;
 export declare function createMachine<TContext, TEvent extends EventObject = AnyEventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: TContext extends Model<any, any, any, any> ? 'Model type no longer supported as generic type. Please use `model.createMachine(...)` instead.' : MachineConfig<TContext, any, TEvent, BaseActionObject, TTypesMeta>, options?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject>>): StateMachine<TContext, any, TEvent, any, BaseActionObject, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject>>;
+}, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: TContext extends Model<any, any, any, any> ? 'Model type no longer supported as generic type. Please use `model.createMachine(...)` instead.' : MachineConfig<TContext, any, TEvent, BaseActionObject, TServiceMap, TTypesMeta>, options?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TServiceMap>>): StateMachine<TContext, any, TEvent, any, BaseActionObject, TServiceMap, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TServiceMap>>;
 //# sourceMappingURL=Machine.d.ts.map

package/lib/SimulatedClock.js

@@ -15,10 +15,14 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimulatedClock = void 0;
@@ -55,7 +59,7 @@ var SimulatedClock = /** @class */ (function () {
     };
     SimulatedClock.prototype.flushTimeouts = function () {
         var _this = this;
-        __spreadArray([], __read(this.timeouts)).sort(function (_a, _b) {
+        __spreadArray([], __read(this.timeouts), false).sort(function (_a, _b) {
             var _c = __read(_a, 2), _idA = _c[0], timeoutA = _c[1];
             var _d = __read(_b, 2), _idB = _d[0], timeoutB = _d[1];
             var endA = timeoutA.start + timeoutA.timeout;

package/lib/State.d.ts

@@ -39,7 +39,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
     /**
      * The enabled state nodes representative of the state value.
      */
-    configuration: Array<StateNode<TContext, any, TEvent, any>>;
+    configuration: Array<StateNode<TContext, any, TEvent, any, any>>;
     /**
      * The next events that will cause a transition from the current state.
      */
@@ -53,7 +53,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      */
     children: Record<string, ActorRef<any>>;
     tags: Set<string>;
-    machine: StateMachine<TContext, any, TEvent, TTypestate, BaseActionObject, TResolvedTypesMeta> | undefined;
+    machine: StateMachine<TContext, any, TEvent, TTypestate, BaseActionObject, any, TResolvedTypesMeta> | undefined;
     /**
      * Creates a new State instance for the given `stateValue` and `context`.
      * @param stateValue
@@ -64,7 +64,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * Creates a new State instance for the given `config`.
      * @param config The state config
      */
-    static create<TC, TE extends EventObject = EventObject>(config: StateConfig<TC, TE>): State<TC, TE>;
+    static create<TC, TE extends EventObject = EventObject>(config: StateConfig<TC, TE>): State<TC, TE, any, any, any>;
     /**
      * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
      * @param stateValue
@@ -90,14 +90,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, "configuration" | "transitions" | "tags" | "machine"> & {
+    toJSON(): Omit<this, "machine" | "tags" | "transitions" | "configuration"> & {
         tags: string[];
     };
     /**
      * Whether the current state value is a subset of the given parent state value.
      * @param parentStateValue
      */
-    matches<TSV extends TTypestate['value']>(parentStateValue: TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'matchesStates'> : TSV): this is State<(TTypestate extends any ? {
+    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'matchesStates'> : TTypestate['value']>(parentStateValue: TSV): this is State<(TTypestate extends any ? {
         value: TSV;
         context: any;
     } extends TTypestate ? TTypestate : never : never)['context'], TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> & {
@@ -109,7 +109,10 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      */
     hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'tags'> : string): boolean;
     /**
-     * Determines whether sending the `event` will cause a transition.
+     * Determines whether sending the `event` will cause a non-forbidden transition
+     * to be selected, even if the transitions have no actions nor
+     * change the state value.
+     *
      * @param event The event to test
      * @returns Whether the event will cause a transition
      */

package/lib/State.js

@@ -215,7 +215,7 @@ function () {
       return _this.toStrings(stateValue[key], delimiter).map(function (s) {
         return key + delimiter + s;
       });
-    }))));
+    })), false));
   };
 
   State.prototype.toJSON = function () {
@@ -249,7 +249,10 @@ function () {
     return this.tags.has(tag);
   };
   /**
-   * Determines whether sending the `event` will cause a transition.
+   * Determines whether sending the `event` will cause a non-forbidden transition
+   * to be selected, even if the transitions have no actions nor
+   * change the state value.
+   *
    * @param event The event to test
    * @returns Whether the event will cause a transition
    */
@@ -262,7 +265,11 @@ function () {
       utils.warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
     }
 
-    return !!((_a = this.machine) === null || _a === void 0 ? void 0 : _a.transition(this, event).changed);
+    var transitionData = (_a = this.machine) === null || _a === void 0 ? void 0 : _a.getTransitionData(this, event);
+    return !!(transitionData === null || transitionData === void 0 ? void 0 : transitionData.transitions.length) && // Check that at least one transition is not forbidden
+    transitionData.transitions.some(function (t) {
+      return t.target !== undefined || t.actions.length;
+    });
   };
 
   return State;

package/lib/StateNode.d.ts

@@ -1,10 +1,10 @@
-import { Event, StateValue, MachineOptions, EventObject, HistoryValue, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, ActivityDefinition, StateNodeConfig, StateSchema, StateNodesConfig, InvokeDefinition, ActionObject, Mapper, PropertyMapper, SCXML, Typestate, TransitionDefinitionMap, MachineSchema, InternalMachineOptions } from './types';
+import { Event, StateValue, StateTransition, MachineOptions, EventObject, HistoryValue, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, ActivityDefinition, StateNodeConfig, StateSchema, StateNodesConfig, InvokeDefinition, ActionObject, Mapper, PropertyMapper, SCXML, Typestate, TransitionDefinitionMap, MachineSchema, InternalMachineOptions, ServiceMap } from './types';
 import { State } from './State';
 import { TypegenDisabled } from './typegenTypes';
 declare class StateNode<TContext = any, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled> {
+}, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = TypegenDisabled> {
     /**
      * The raw config used to create the machine.
      */
@@ -82,7 +82,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     /**
      * The parent state node.
      */
-    parent?: StateNode<TContext, any, TEvent, any>;
+    parent?: StateNode<TContext, any, TEvent, any, any, any>;
     /**
      * The root machine node.
      */
@@ -126,7 +126,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      */
     _context?: Readonly<TContext> | (() => Readonly<TContext>), // TODO: this is unsafe, but we're removing it in v5 anyway
     _stateInfo?: {
-        parent: StateNode<any, any, any, any, any>;
+        parent: StateNode<any, any, any, any, any, any>;
         key: string;
     });
     private _init;
@@ -136,7 +136,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param options Options (actions, guards, activities, services) to recursively merge with the existing options.
      * @param context Custom context (will override predefined context)
      */
-    withConfig(options: InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateNode<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
+    withConfig(options: InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta>;
     /**
      * Clones this state machine with custom context.
      *
@@ -168,7 +168,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      *
      * @param state The state value or State instance
      */
-    getStateNodes(state: StateValue | State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>): Array<StateNode<TContext, any, TEvent, TTypestate, TResolvedTypesMeta>>;
+    getStateNodes(state: StateValue | State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>): Array<StateNode<TContext, any, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta>>;
     /**
      * Returns `true` if this state node explicitly handles the given event.
      *
@@ -187,6 +187,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     private transitionCompoundNode;
     private transitionParallelNode;
     private _transition;
+    getTransitionData(state: State<TContext, TEvent, any, any, any>, event: Event<TEvent> | SCXML.Event<TEvent>): StateTransition<TContext, TEvent> | undefined;
     private next;
     private nodesFromChild;
     /**
@@ -208,19 +209,19 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     /**
      * Returns the child state node from its relative `stateKey`, or throws.
      */
-    getStateNode(stateKey: string): StateNode<TContext, any, TEvent, TTypestate, TResolvedTypesMeta>;
+    getStateNode(stateKey: string): StateNode<TContext, any, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta>;
     /**
      * Returns the state node with the given `stateId`, or throws.
      *
      * @param stateId The state ID. The prefix "#" is removed.
      */
-    getStateNodeById(stateId: string): StateNode<TContext, any, TEvent, any, TResolvedTypesMeta>;
+    getStateNodeById(stateId: string): StateNode<TContext, any, TEvent, any, TServiceMap, TResolvedTypesMeta>;
     /**
      * Returns the relative state node from the given `statePath`, or throws.
      *
      * @param statePath The string or string array relative path to the state node.
      */
-    getStateNodeByPath(statePath: string | string[]): StateNode<TContext, any, TEvent, any, any>;
+    getStateNodeByPath(statePath: string | string[]): StateNode<TContext, any, TEvent, any, any, any>;
     /**
      * Resolves a partial state value with its full representation in this machine.
      *
@@ -248,14 +249,14 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param resolve Whether state nodes should resolve to initial child state nodes
      */
     getRelativeStateNodes(relativeStateId: StateNode<TContext, any, TEvent>, historyValue?: HistoryValue, resolve?: boolean): Array<StateNode<TContext, any, TEvent>>;
-    get initialStateNodes(): Array<StateNode<TContext, any, TEvent, any, any>>;
+    get initialStateNodes(): Array<StateNode<TContext, any, TEvent, any, any, any>>;
     /**
      * Retrieves state nodes from a relative path to this state node.
      *
      * @param relativePath The relative path from this state node
      * @param historyValue
      */
-    getFromRelativePath(relativePath: string[]): Array<StateNode<TContext, any, TEvent, any, any>>;
+    getFromRelativePath(relativePath: string[]): Array<StateNode<TContext, any, TEvent, any, any, any>>;
     private historyValue;
     /**
      * Resolves to the historical value(s) of the parent state node,