xstate 4.30.2 → 4.30.5

package/lib/index.d.ts

@@ -1,17 +1,19 @@
-import { matchesState } from './utils';
-import { mapState } from './mapState';
-import { StateNode } from './StateNode';
-import { State } from './State';
-import { Machine, createMachine } from './Machine';
-import { Actor, toActorRef } from './Actor';
 import * as actions from './actions';
-import { interpret, Interpreter, spawn, InterpreterStatus } from './interpreter';
+import { Actor, toActorRef } from './Actor';
+import { interpret, Interpreter, InterpreterStatus, spawn } from './interpreter';
+import { createMachine, Machine } from './Machine';
+import { mapState } from './mapState';
 import { matchState } from './match';
 import { createSchema, t } from './schema';
-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, toActorRef, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
-export * from './types';
+import { State } from './State';
+import { StateNode } from './StateNode';
+export { spawnBehavior } from './behaviors';
+export { XStateDevInterface } from './devTools';
 export * from './typegenTypes';
+export * from './types';
+export { matchesState, toEventObject, toObserver, toSCXMLEvent } from './utils';
+export { Actor, toActorRef, Machine, StateNode, State, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
+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;
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/lib/index.js

@@ -2,17 +2,18 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var utils = require('./utils.js');
-var mapState = require('./mapState.js');
-var types = require('./types.js');
 var actions = require('./actions.js');
-var State = require('./State.js');
 var Actor = require('./Actor.js');
-var StateNode = require('./StateNode.js');
-var Machine = require('./Machine.js');
 var interpreter = require('./interpreter.js');
+var Machine = require('./Machine.js');
+var mapState = require('./mapState.js');
 var match = require('./match.js');
 var schema = require('./schema.js');
+var State = require('./State.js');
+var StateNode = require('./StateNode.js');
+var behaviors = require('./behaviors.js');
+var types = require('./types.js');
+var utils = require('./utils.js');
 
 var assign = actions.assign,
     send = actions.send,
@@ -21,38 +22,36 @@ var assign = actions.assign,
     forwardTo = actions.forwardTo,
     doneInvoke = actions.doneInvoke;
 
-exports.matchesState = utils.matchesState;
-exports.mapState = mapState.mapState;
-Object.defineProperty(exports, 'ActionTypes', {
-  enumerable: true,
-  get: function () {
-    return types.ActionTypes;
-  }
-});
-Object.defineProperty(exports, 'SpecialTargets', {
-  enumerable: true,
-  get: function () {
-    return types.SpecialTargets;
-  }
-});
 exports.actions = actions;
-exports.State = State.State;
 exports.toActorRef = Actor.toActorRef;
-exports.StateNode = StateNode.StateNode;
-exports.Machine = Machine.Machine;
-exports.createMachine = Machine.createMachine;
 exports.Interpreter = interpreter.Interpreter;
 Object.defineProperty(exports, 'InterpreterStatus', {
   enumerable: true,
-  get: function () {
-    return interpreter.InterpreterStatus;
-  }
+  get: function () { return interpreter.InterpreterStatus; }
 });
 exports.interpret = interpreter.interpret;
 exports.spawn = interpreter.spawn;
+exports.Machine = Machine.Machine;
+exports.createMachine = Machine.createMachine;
+exports.mapState = mapState.mapState;
 exports.matchState = match.matchState;
 exports.createSchema = schema.createSchema;
 exports.t = schema.t;
+exports.State = State.State;
+exports.StateNode = StateNode.StateNode;
+exports.spawnBehavior = behaviors.spawnBehavior;
+Object.defineProperty(exports, 'ActionTypes', {
+  enumerable: true,
+  get: function () { return types.ActionTypes; }
+});
+Object.defineProperty(exports, 'SpecialTargets', {
+  enumerable: true,
+  get: function () { return types.SpecialTargets; }
+});
+exports.matchesState = utils.matchesState;
+exports.toEventObject = utils.toEventObject;
+exports.toObserver = utils.toObserver;
+exports.toSCXMLEvent = utils.toSCXMLEvent;
 exports.assign = assign;
 exports.doneInvoke = doneInvoke;
 exports.forwardTo = forwardTo;

package/lib/interpreter.d.ts

@@ -23,6 +23,7 @@ export declare enum InterpreterStatus {
     Running = 1,
     Stopped = 2
 }
+/** @ts-ignore [symbolObservable] creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
 export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -189,6 +190,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     toJSON(): {
         id: string;
     };
+    /** @ts-ignore this creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
     [symbolObservable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
     getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
 }

package/lib/interpreter.js

@@ -3,30 +3,33 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
-var environment = require('./environment.js');
-var utils = require('./utils.js');
 var types = require('./types.js');
-var stateUtils = require('./stateUtils.js');
+var State = require('./State.js');
 var actionTypes = require('./actionTypes.js');
 var actions = require('./actions.js');
-var State = require('./State.js');
-var serviceScope = require('./serviceScope.js');
-var Actor = require('./Actor.js');
+var environment = require('./environment.js');
+var utils = require('./utils.js');
 var scheduler = require('./scheduler.js');
+var Actor = require('./Actor.js');
+var stateUtils = require('./stateUtils.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__*/
@@ -594,7 +597,7 @@ function () {
 
     try {
       // Cancel all delayed events
-      for (var _p = _tslib.__values(utils.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
+      for (var _p = _tslib.__values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
         var key = _q.value;
         this.clock.clearTimeout(this.delayedEventsMap[key]);
       }
@@ -1311,6 +1314,8 @@ 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;

package/lib/invokeUtils.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
-require('./environment.js');
-require('./utils.js');
 require('./types.js');
 var actionTypes = require('./actionTypes.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/mapState.js

@@ -11,7 +11,7 @@ function mapState(stateMap, stateId) {
   var foundStateId;
 
   try {
-    for (var _b = _tslib.__values(utils.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+    for (var _b = _tslib.__values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
       var mappedStateId = _c.value;
 
       if (utils.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {

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/scxml.js

@@ -108,7 +108,7 @@ function delayToMs(delay) {
 }
 var evaluateExecutableContent = function (context, _ev, meta, body) {
     var datamodel = context
-        ? (0, utils_1.keys)(context)
+        ? Object.keys(context)
             .map(function (key) { return "const ".concat(key, " = context['").concat(key, "'];"); })
             .join('\n')
         : '';

package/lib/stateUtils.js

@@ -9,7 +9,7 @@ var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
 };
 function getChildren(stateNode) {
-  return utils.keys(stateNode.states).map(function (key) {
+  return Object.keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
   });
 }