xstate 4.29.0 → 4.30.0

package/lib/StateNode.js

@@ -441,9 +441,10 @@ function () {
 
 
   StateNode.prototype.resolveState = function (state) {
-    var configuration = Array.from(stateUtils.getConfiguration([], this.getStateNodes(state.value)));
-    return new State.State(_tslib.__assign(_tslib.__assign({}, state), {
-      value: this.resolve(state.value),
+    var stateFromConfig = state instanceof State.State ? state : State.State.create(state);
+    var configuration = Array.from(stateUtils.getConfiguration([], this.getStateNodes(stateFromConfig.value)));
+    return new State.State(_tslib.__assign(_tslib.__assign({}, stateFromConfig), {
+      value: this.resolve(stateFromConfig.value),
       configuration: configuration,
       done: stateUtils.isInFinalState(configuration, this),
       tags: stateUtils.getTagsFromConfiguration(configuration)
@@ -1145,6 +1146,9 @@ function () {
   });
 
   StateNode.prototype.getInitialState = function (stateValue, context) {
+    this._init(); // TODO: this should be in the constructor (see note in constructor)
+
+
     var configuration = this.getStateNodes(stateValue);
     return this.resolveTransition({
       configuration: configuration,
@@ -1162,9 +1166,6 @@ function () {
      * entering the initial state.
      */
     get: function () {
-      this._init(); // TODO: this should be in the constructor (see note in constructor)
-
-
       var initialStateValue = this.initialStateValue;
 
       if (!initialStateValue) {

package/lib/actions.js

@@ -292,6 +292,9 @@ var assign = function (assignment) {
     assignment: assignment
   };
 };
+function isActionObject(action) {
+  return typeof action === 'object' && 'type' in action;
+}
 /**
  * Returns an event type that represents an implicit event that
  * is sent after the specified `delay`.
@@ -516,6 +519,7 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
   return [resolvedActions, updatedContext];
 }
 
+exports.actionTypes = actionTypes;
 exports.after = after;
 exports.assign = assign;
 exports.cancel = cancel;
@@ -527,6 +531,7 @@ exports.escalate = escalate;
 exports.forwardTo = forwardTo;
 exports.getActionFunction = getActionFunction;
 exports.initEvent = initEvent;
+exports.isActionObject = isActionObject;
 exports.log = log;
 exports.pure = pure;
 exports.raise = raise;

package/lib/index.d.ts

@@ -4,29 +4,11 @@ import { StateNode } from './StateNode';
 import { State } from './State';
 import { Machine, createMachine } from './Machine';
 import { Actor } from './Actor';
-import { raise, send, sendParent, sendTo, sendUpdate, log, start, stop, assign, after, done, respond, doneInvoke, forwardTo, escalate, choose, pure } from './actions';
+import * as actions from './actions';
 import { interpret, Interpreter, spawn, InterpreterStatus } from './interpreter';
 import { matchState } from './match';
 import { createSchema, t } from './schema';
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    sendUpdate: typeof sendUpdate;
-    log: typeof log;
-    cancel: (sendId: string | number) => import("./types").CancelAction;
-    start: typeof start;
-    stop: typeof stop;
-    assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
+declare const assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>, send: typeof actions.send, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke;
 export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
 export * from './types';
 export * from './typegenTypes';

package/lib/index.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var utils = require('./utils.js');
 var mapState = require('./mapState.js');
 var types = require('./types.js');
-var actions$1 = require('./actions.js');
+var actions = require('./actions.js');
 var State = require('./State.js');
 var StateNode = require('./StateNode.js');
 var Machine = require('./Machine.js');
@@ -13,25 +13,12 @@ var interpreter = require('./interpreter.js');
 var match = require('./match.js');
 var schema = require('./schema.js');
 
-var actions = {
-  raise: actions$1.raise,
-  send: actions$1.send,
-  sendParent: actions$1.sendParent,
-  sendTo: actions$1.sendTo,
-  sendUpdate: actions$1.sendUpdate,
-  log: actions$1.log,
-  cancel: actions$1.cancel,
-  start: actions$1.start,
-  stop: actions$1.stop,
-  assign: actions$1.assign,
-  after: actions$1.after,
-  done: actions$1.done,
-  respond: actions$1.respond,
-  forwardTo: actions$1.forwardTo,
-  escalate: actions$1.escalate,
-  choose: actions$1.choose,
-  pure: actions$1.pure
-};
+var assign = actions.assign,
+    send = actions.send,
+    sendParent = actions.sendParent,
+    sendUpdate = actions.sendUpdate,
+    forwardTo = actions.forwardTo,
+    doneInvoke = actions.doneInvoke;
 
 exports.matchesState = utils.matchesState;
 exports.mapState = mapState.mapState;
@@ -47,12 +34,7 @@ Object.defineProperty(exports, 'SpecialTargets', {
     return types.SpecialTargets;
   }
 });
-exports.assign = actions$1.assign;
-exports.doneInvoke = actions$1.doneInvoke;
-exports.forwardTo = actions$1.forwardTo;
-exports.send = actions$1.send;
-exports.sendParent = actions$1.sendParent;
-exports.sendUpdate = actions$1.sendUpdate;
+exports.actions = actions;
 exports.State = State.State;
 exports.StateNode = StateNode.StateNode;
 exports.Machine = Machine.Machine;
@@ -69,4 +51,9 @@ exports.spawn = interpreter.spawn;
 exports.matchState = match.matchState;
 exports.createSchema = schema.createSchema;
 exports.t = schema.t;
-exports.actions = actions;
+exports.assign = assign;
+exports.doneInvoke = doneInvoke;
+exports.forwardTo = forwardTo;
+exports.send = send;
+exports.sendParent = sendParent;
+exports.sendUpdate = sendUpdate;

package/lib/interpreter.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
 import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, Subscribable, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription } from './types';
 import { State } from './State';
+import { StateConfig } from '.';
 import { AreAllImplementationsAssumedToBeProvided, TypegenDisabled } from './typegenTypes';
 export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
@@ -37,10 +37,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     static defaultOptions: {
         execute: boolean;
         deferEvents: boolean;
-        clock: {
-            setTimeout: (fn: any, ms: any) => NodeJS.Timeout;
-            clearTimeout: (id: any) => void;
-        };
+        clock: Clock;
         logger: any;
         devTools: boolean;
     };
@@ -131,12 +128,12 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | undefined) => this;
+    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | undefined) => this;
     /**
      * Starts the interpreter from the given state, or the initial state.
      * @param initialState The state to start the statechart from
      */
-    start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateValue): this;
+    start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue): this;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *

package/lib/interpreter.js

@@ -462,7 +462,7 @@ function () {
     this.initialized = true;
     this.status = exports.InterpreterStatus.Running;
     var resolvedState = initialState === undefined ? this.initialState : serviceScope.provide(this, function () {
-      return State.isState(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.State.from(initialState, _this.machine.context));
+      return State.isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.State.from(initialState, _this.machine.context));
     });
 
     if (this.options.devTools) {

package/lib/types.d.ts

@@ -564,6 +564,7 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
     target: StateValue | undefined;
 }
+/** @ts-ignore TS complains about withConfig & withContext not being compatible here when extending StateNode */
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -572,12 +573,19 @@ export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent
     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>;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TContext: TContext;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TStateSchema: TStateSchema;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TEvent: TEvent;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TTypestate: TTypestate;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TAction: TAction;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TServiceMap: TServiceMap;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TResolvedTypesMeta: TResolvedTypesMeta;
 }
 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;

package/package.json

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