xstate 4.30.4 → 4.31.0

package/lib/interpreter.js

@@ -4,31 +4,30 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
 var types = require('./types.js');
+var State = require('./State.js');
 var actionTypes = require('./actionTypes.js');
+var actions = require('./actions.js');
 var environment = require('./environment.js');
 var utils = require('./utils.js');
-var actions = require('./actions.js');
-var serviceScope = require('./serviceScope.js');
+var scheduler = require('./scheduler.js');
 var Actor = require('./Actor.js');
 var stateUtils = require('./stateUtils.js');
-var State = require('./State.js');
-var scheduler = require('./scheduler.js');
 var registry = require('./registry.js');
 var devTools = require('./devTools.js');
+var serviceScope = require('./serviceScope.js');
 var behaviors = require('./behaviors.js');
 
 var DEFAULT_SPAWN_OPTIONS = {
   sync: false,
   autoForward: false
 };
+exports.InterpreterStatus = void 0;
 
 (function (InterpreterStatus) {
   InterpreterStatus[InterpreterStatus["NotStarted"] = 0] = "NotStarted";
   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__*/
@@ -49,7 +48,6 @@ function () {
     }
 
     this.machine = machine;
-    this.scheduler = new scheduler.Scheduler();
     this.delayedEventsMap = {};
     this.listeners = new Set();
     this.contextListeners = new Set();
@@ -366,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 {
@@ -458,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;
@@ -593,6 +601,7 @@ function () {
         child.stop();
       }
     });
+    this.children.clear();
 
     try {
       // Cancel all delayed events
@@ -613,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;
   };
@@ -1313,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;
@@ -1335,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/invokeUtils.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('./_virtual/_tslib.js');
 require('./types.js');
 var actionTypes = require('./actionTypes.js');
-require('./environment.js');
 require('./utils.js');
+require('./environment.js');
 
 function toInvokeSource(src) {
   if (typeof src === 'string') {
@@ -29,9 +29,9 @@ function toInvokeDefinition(invokeConfig) {
     type: actionTypes.invoke
   }, invokeConfig), {
     toJSON: function () {
-      var onDone = invokeConfig.onDone,
-          onError = invokeConfig.onError,
-          invokeDef = _tslib.__rest(invokeConfig, ["onDone", "onError"]);
+      invokeConfig.onDone;
+          invokeConfig.onError;
+          var invokeDef = _tslib.__rest(invokeConfig, ["onDone", "onError"]);
 
       return _tslib.__assign(_tslib.__assign({}, invokeDef), {
         type: actionTypes.invoke,

package/lib/json.js

@@ -1,85 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonify = exports.parse = exports.stringify = exports.machineToJSON = exports.stringifyFunction = void 0;
-var utils_1 = require("./utils");
-// tslint:disable-next-line:ban-types
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils.js');
+
 function stringifyFunction(fn) {
-    return {
-        $function: fn.toString()
-    };
+  return {
+    $function: fn.toString()
+  };
 }
-exports.stringifyFunction = stringifyFunction;
+
 function getStateNodeId(stateNode) {
-    return "#".concat(stateNode.id);
-}
-// derive config from machine
+  return "#".concat(stateNode.id);
+} // derive config from machine
+
+
 function machineToJSON(stateNode) {
-    var config = {
-        type: stateNode.type,
-        initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
-        id: stateNode.id,
-        key: stateNode.key,
-        entry: stateNode.onEntry,
-        exit: stateNode.onExit,
-        on: (0, utils_1.mapValues)(stateNode.on, function (transition) {
-            return transition.map(function (t) {
-                return {
-                    target: t.target ? t.target.map(getStateNodeId) : [],
-                    source: getStateNodeId(t.source),
-                    actions: t.actions,
-                    cond: t.cond,
-                    eventType: t.eventType
-                };
-            });
-        }),
-        invoke: stateNode.invoke,
-        states: {}
-    };
-    Object.values(stateNode.states).forEach(function (sn) {
-        config.states[sn.key] = machineToJSON(sn);
-    });
-    return config;
+  var config = {
+    type: stateNode.type,
+    initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
+    id: stateNode.id,
+    key: stateNode.key,
+    entry: stateNode.onEntry,
+    exit: stateNode.onExit,
+    on: utils.mapValues(stateNode.on, function (transition) {
+      return transition.map(function (t) {
+        return {
+          target: t.target ? t.target.map(getStateNodeId) : [],
+          source: getStateNodeId(t.source),
+          actions: t.actions,
+          cond: t.cond,
+          eventType: t.eventType
+        };
+      });
+    }),
+    invoke: stateNode.invoke,
+    states: {}
+  };
+  Object.values(stateNode.states).forEach(function (sn) {
+    config.states[sn.key] = machineToJSON(sn);
+  });
+  return config;
 }
-exports.machineToJSON = machineToJSON;
 function stringify(machine) {
-    return JSON.stringify(machineToJSON(machine), function (_, value) {
-        if ((0, utils_1.isFunction)(value)) {
-            return { $function: value.toString() };
-        }
-        return value;
-    });
+  return JSON.stringify(machineToJSON(machine), function (_, value) {
+    if (utils.isFunction(value)) {
+      return {
+        $function: value.toString()
+      };
+    }
+
+    return value;
+  });
 }
-exports.stringify = stringify;
 function parse(machineString) {
-    var config = JSON.parse(machineString, function (_, value) {
-        if (typeof value === 'object' && '$function' in value) {
-            return new Function(value.value);
-        }
-        return value;
-    });
-    return config;
+  var config = JSON.parse(machineString, function (_, value) {
+    if (typeof value === 'object' && '$function' in value) {
+      return new Function(value.value);
+    }
+
+    return value;
+  });
+  return config;
 }
-exports.parse = parse;
 function jsonify(value) {
-    Object.defineProperty(value, 'toJSON', {
-        value: function () {
-            return (0, utils_1.mapValues)(value, function (subValue) {
-                if ((0, utils_1.isFunction)(subValue)) {
-                    return stringifyFunction(subValue);
-                }
-                else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
-                    // mostly for assignments
-                    return (0, utils_1.mapValues)(subValue, function (subSubValue) {
-                        if ((0, utils_1.isFunction)(subSubValue)) {
-                            return stringifyFunction(subSubValue);
-                        }
-                        return subSubValue;
-                    });
-                }
-                return subValue;
-            });
+  Object.defineProperty(value, 'toJSON', {
+    value: function () {
+      return utils.mapValues(value, function (subValue) {
+        if (utils.isFunction(subValue)) {
+          return stringifyFunction(subValue);
+        } else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
+          // mostly for assignments
+          return utils.mapValues(subValue, function (subSubValue) {
+            if (utils.isFunction(subSubValue)) {
+              return stringifyFunction(subSubValue);
+            }
+
+            return subSubValue;
+          });
         }
-    });
-    return value;
+
+        return subValue;
+      });
+    }
+  });
+  return value;
 }
+
 exports.jsonify = jsonify;
+exports.machineToJSON = machineToJSON;
+exports.parse = parse;
+exports.stringify = stringify;
+exports.stringifyFunction = stringifyFunction;

package/lib/model.js

@@ -1,74 +1,54 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+var actions = require('./actions.js');
+var Machine = require('./Machine.js');
+var utils = require('./utils.js');
+
+function createModel(initialContext, creators) {
+  var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
+  var actionCreators = creators === null || creators === void 0 ? void 0 : creators.actions;
+  var model = {
+    initialContext: initialContext,
+    assign: actions.assign,
+    events: eventCreators ? utils.mapValues(eventCreators, function (fn, eventType) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
         }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-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 _tslib.__assign(_tslib.__assign({}, fn.apply(void 0, _tslib.__spreadArray([], _tslib.__read(args), false))), {
+          type: eventType
+        });
+      };
+    }) : undefined,
+    actions: actionCreators ? utils.mapValues(actionCreators, function (fn, actionType) {
+      return function () {
+        var args = [];
+
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
         }
+
+        return _tslib.__assign(_tslib.__assign({}, fn.apply(void 0, _tslib.__spreadArray([], _tslib.__read(args), false))), {
+          type: actionType
+        });
+      };
+    }) : undefined,
+    reset: function () {
+      return actions.assign(initialContext);
+    },
+    createMachine: function (config, implementations) {
+      return Machine.createMachine('context' in config ? config : _tslib.__assign(_tslib.__assign({}, config), {
+        context: initialContext
+      }), implementations);
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModel = void 0;
-var actions_1 = require("./actions");
-var Machine_1 = require("./Machine");
-var utils_1 = require("./utils");
-function createModel(initialContext, creators) {
-    var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
-    var actionCreators = creators === null || creators === void 0 ? void 0 : creators.actions;
-    var model = {
-        initialContext: initialContext,
-        assign: actions_1.assign,
-        events: (eventCreators
-            ? (0, utils_1.mapValues)(eventCreators, function (fn, eventType) { return function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), { type: eventType }));
-            }; })
-            : undefined),
-        actions: actionCreators
-            ? (0, utils_1.mapValues)(actionCreators, function (fn, actionType) { return function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), { type: actionType }));
-            }; })
-            : undefined,
-        reset: function () { return (0, actions_1.assign)(initialContext); },
-        createMachine: function (config, implementations) {
-            return (0, Machine_1.createMachine)('context' in config ? config : __assign(__assign({}, config), { context: initialContext }), implementations);
-        }
-    };
-    return model;
+  };
+  return model;
 }
+
 exports.createModel = createModel;

package/lib/patterns.js

@@ -1,61 +1,53 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sequence = exports.toggle = void 0;
-var utils_1 = require("./utils");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+var utils = require('./utils.js');
+
 function toggle(onState, offState, eventType) {
-    var _a, _b, _c;
-    return _a = {},
-        _a[onState] = {
-            on: (_b = {}, _b[eventType] = offState, _b)
-        },
-        _a[offState] = {
-            on: (_c = {}, _c[eventType] = onState, _c)
-        },
-        _a;
+  var _a, _b, _c;
+
+  return _a = {}, _a[onState] = {
+    on: (_b = {}, _b[eventType] = offState, _b)
+  }, _a[offState] = {
+    on: (_c = {}, _c[eventType] = onState, _c)
+  }, _a;
 }
-exports.toggle = toggle;
 var defaultSequencePatternOptions = {
-    nextEvent: 'NEXT',
-    prevEvent: 'PREV'
+  nextEvent: 'NEXT',
+  prevEvent: 'PREV'
 };
 function sequence(items, options) {
-    var resolvedOptions = __assign(__assign({}, defaultSequencePatternOptions), options);
-    var states = {};
-    var nextEventObject = resolvedOptions.nextEvent === undefined
-        ? undefined
-        : (0, utils_1.toEventObject)(resolvedOptions.nextEvent);
-    var prevEventObject = resolvedOptions.prevEvent === undefined
-        ? undefined
-        : (0, utils_1.toEventObject)(resolvedOptions.prevEvent);
-    items.forEach(function (item, i) {
-        var state = {
-            on: {}
-        };
-        if (i + 1 === items.length) {
-            state.type = 'final';
-        }
-        if (nextEventObject && i + 1 < items.length) {
-            state.on[nextEventObject.type] = items[i + 1];
-        }
-        if (prevEventObject && i > 0) {
-            state.on[prevEventObject.type] = items[i - 1];
-        }
-        states[item] = state;
-    });
-    return {
-        initial: items[0],
-        states: states
+  var resolvedOptions = _tslib.__assign(_tslib.__assign({}, defaultSequencePatternOptions), options);
+
+  var states = {};
+  var nextEventObject = resolvedOptions.nextEvent === undefined ? undefined : utils.toEventObject(resolvedOptions.nextEvent);
+  var prevEventObject = resolvedOptions.prevEvent === undefined ? undefined : utils.toEventObject(resolvedOptions.prevEvent);
+  items.forEach(function (item, i) {
+    var state = {
+      on: {}
     };
+
+    if (i + 1 === items.length) {
+      state.type = 'final';
+    }
+
+    if (nextEventObject && i + 1 < items.length) {
+      state.on[nextEventObject.type] = items[i + 1];
+    }
+
+    if (prevEventObject && i > 0) {
+      state.on[prevEventObject.type] = items[i - 1];
+    }
+
+    states[item] = state;
+  });
+  return {
+    initial: items[0],
+    states: states
+  };
 }
+
 exports.sequence = sequence;
+exports.toggle = toggle;

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,20 @@ 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: 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;
+            };
         };
+        invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
     };
-    invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
-};
+}
 export {};
 //# sourceMappingURL=typegenTypes.d.ts.map