xstate 4.30.4 → 4.30.5

package/es/json.js

@@ -0,0 +1,86 @@
+import { mapValues, isFunction } from './utils.js';
+
+function stringifyFunction(fn) {
+  return {
+    $function: fn.toString()
+  };
+}
+
+function getStateNodeId(stateNode) {
+  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: 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;
+}
+function stringify(machine) {
+  return JSON.stringify(machineToJSON(machine), function (_, value) {
+    if (isFunction(value)) {
+      return {
+        $function: value.toString()
+      };
+    }
+
+    return value;
+  });
+}
+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;
+}
+function jsonify(value) {
+  Object.defineProperty(value, 'toJSON', {
+    value: function () {
+      return mapValues(value, function (subValue) {
+        if (isFunction(subValue)) {
+          return stringifyFunction(subValue);
+        } else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
+          // mostly for assignments
+          return mapValues(subValue, function (subSubValue) {
+            if (isFunction(subSubValue)) {
+              return stringifyFunction(subSubValue);
+            }
+
+            return subSubValue;
+          });
+        }
+
+        return subValue;
+      });
+    }
+  });
+  return value;
+}
+
+export { jsonify, machineToJSON, parse, stringify, stringifyFunction };

package/es/model.js

@@ -0,0 +1,50 @@
+import { __assign, __spreadArray, __read } from './_virtual/_tslib.js';
+import { assign } from './actions.js';
+import { createMachine } from './Machine.js';
+import { mapValues } from './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: assign,
+    events: eventCreators ? 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 ? 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 assign(initialContext);
+    },
+    createMachine: function (config, implementations) {
+      return createMachine('context' in config ? config : __assign(__assign({}, config), {
+        context: initialContext
+      }), implementations);
+    }
+  };
+  return model;
+}
+
+export { createModel };

package/es/patterns.js

@@ -0,0 +1,48 @@
+import { __assign } from './_virtual/_tslib.js';
+import { toEventObject } from './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 defaultSequencePatternOptions = {
+  nextEvent: 'NEXT',
+  prevEvent: 'PREV'
+};
+function sequence(items, options) {
+  var resolvedOptions = __assign(__assign({}, defaultSequencePatternOptions), options);
+
+  var states = {};
+  var nextEventObject = resolvedOptions.nextEvent === undefined ? undefined : toEventObject(resolvedOptions.nextEvent);
+  var prevEventObject = resolvedOptions.prevEvent === undefined ? undefined : 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
+  };
+}
+
+export { sequence, toggle };

package/es/utils.js

@@ -1,8 +1,11 @@
-import { __assign, __spreadArray, __read, __values } from './_virtual/_tslib.js';
+import { __values, __spreadArray, __read, __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);
+}
 function matchesState(parentStateId, childStateId, delimiter) {
   if (delimiter === void 0) {
     delimiter = STATE_DELIMITER;
@@ -39,6 +42,13 @@ function getEventType(event) {
     throw new Error('Events must be strings or objects with a string event.type property.');
   }
 }
+function getActionType(action) {
+  try {
+    return isString(action) || typeof action === 'number' ? "".concat(action) : isFunction(action) ? action.name : action.type;
+  } catch (e) {
+    throw new Error('Actions must be strings or objects with a string action.type property.');
+  }
+}
 function toStatePath(stateId, delimiter) {
   try {
     if (isArray(stateId)) {
@@ -213,6 +223,46 @@ function toStatePaths(stateValue) {
   }));
   return result;
 }
+function pathsToStateValue(paths) {
+  var e_4, _a;
+
+  var result = {};
+
+  if (paths && paths.length === 1 && paths[0].length === 1) {
+    return paths[0][0];
+  }
+
+  try {
+    for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+      var currentPath = paths_1_1.value;
+      var marker = result; // tslint:disable-next-line:prefer-for-of
+
+      for (var i = 0; i < currentPath.length; i++) {
+        var subPath = currentPath[i];
+
+        if (i === currentPath.length - 2) {
+          marker[subPath] = currentPath[i + 1];
+          break;
+        }
+
+        marker[subPath] = marker[subPath] || {};
+        marker = marker[subPath];
+      }
+    }
+  } catch (e_4_1) {
+    e_4 = {
+      error: e_4_1
+    };
+  } finally {
+    try {
+      if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+    } finally {
+      if (e_4) throw e_4.error;
+    }
+  }
+
+  return result;
+}
 function flatten(array) {
   var _a;
 
@@ -573,4 +623,4 @@ function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
 
-export { createInvokeId, evaluateGuard, flatten, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, 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, getActionType, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, pathsToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

package/lib/SimulatedClock.js

@@ -1,83 +1,85 @@
-"use strict";
-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);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+
+var SimulatedClock =
+/*#__PURE__*/
+
+/** @class */
+function () {
+  function SimulatedClock() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+
+  SimulatedClock.prototype.now = function () {
+    return this._now;
+  };
+
+  SimulatedClock.prototype.getId = function () {
+    return this._id++;
+  };
+
+  SimulatedClock.prototype.setTimeout = function (fn, timeout) {
+    var id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout: timeout,
+      fn: fn
+    });
+    return id;
+  };
+
+  SimulatedClock.prototype.clearTimeout = function (id) {
+    this.timeouts.delete(id);
+  };
+
+  SimulatedClock.prototype.set = function (time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
     }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(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 to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimulatedClock = void 0;
-var SimulatedClock = /** @class */ (function () {
-    function SimulatedClock() {
-        this.timeouts = new Map();
-        this._now = 0;
-        this._id = 0;
-    }
-    SimulatedClock.prototype.now = function () {
-        return this._now;
-    };
-    SimulatedClock.prototype.getId = function () {
-        return this._id++;
-    };
-    SimulatedClock.prototype.setTimeout = function (fn, timeout) {
-        var id = this.getId();
-        this.timeouts.set(id, {
-            start: this.now(),
-            timeout: timeout,
-            fn: fn
-        });
-        return id;
-    };
-    SimulatedClock.prototype.clearTimeout = function (id) {
-        this.timeouts.delete(id);
-    };
-    SimulatedClock.prototype.set = function (time) {
-        if (this._now > time) {
-            throw new Error('Unable to travel back in time');
-        }
-        this._now = time;
-        this.flushTimeouts();
-    };
-    SimulatedClock.prototype.flushTimeouts = function () {
-        var _this = this;
-        __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;
-            var endB = timeoutB.start + timeoutB.timeout;
-            return endB > endA ? -1 : 1;
-        })
-            .forEach(function (_a) {
-            var _b = __read(_a, 2), id = _b[0], timeout = _b[1];
-            if (_this.now() - timeout.start >= timeout.timeout) {
-                _this.timeouts.delete(id);
-                timeout.fn.call(null);
-            }
-        });
-    };
-    SimulatedClock.prototype.increment = function (ms) {
-        this._now += ms;
-        this.flushTimeouts();
-    };
-    return SimulatedClock;
-}());
+
+    this._now = time;
+    this.flushTimeouts();
+  };
+
+  SimulatedClock.prototype.flushTimeouts = function () {
+    var _this = this;
+
+    _tslib.__spreadArray([], _tslib.__read(this.timeouts), false).sort(function (_a, _b) {
+      var _c = _tslib.__read(_a, 2);
+          _c[0];
+          var timeoutA = _c[1];
+
+      var _d = _tslib.__read(_b, 2);
+          _d[0];
+          var timeoutB = _d[1];
+
+      var endA = timeoutA.start + timeoutA.timeout;
+      var endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(function (_a) {
+      var _b = _tslib.__read(_a, 2),
+          id = _b[0],
+          timeout = _b[1];
+
+      if (_this.now() - timeout.start >= timeout.timeout) {
+        _this.timeouts.delete(id);
+
+        timeout.fn.call(null);
+      }
+    });
+  };
+
+  SimulatedClock.prototype.increment = function (ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  };
+
+  return SimulatedClock;
+}();
+
 exports.SimulatedClock = SimulatedClock;

package/lib/State.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
 var constants = require('./constants.js');
-var environment = require('./environment.js');
 var utils = require('./utils.js');
-var actions = require('./actions.js');
 var stateUtils = require('./stateUtils.js');
+var actions = require('./actions.js');
+var environment = require('./environment.js');
 
 function stateValuesEqual(a, b) {
   if (a === b) {
@@ -35,6 +35,11 @@ function isStateConfig(state) {
 
   return 'value' in state && '_event' in state;
 }
+/**
+ * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
+ */
+
+var isState = isStateConfig;
 function bindActionToState(action, state) {
   var exec = action.exec;
 
@@ -219,12 +224,12 @@ function () {
   };
 
   State.prototype.toJSON = function () {
-    var _a = this,
-        configuration = _a.configuration,
-        transitions = _a.transitions,
-        tags = _a.tags,
-        machine = _a.machine,
-        jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags", "machine"]);
+    var _a = this;
+        _a.configuration;
+        _a.transitions;
+        var tags = _a.tags;
+        _a.machine;
+        var jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags", "machine"]);
 
     return _tslib.__assign(_tslib.__assign({}, jsonValues), {
       tags: Array.from(tags)
@@ -272,5 +277,6 @@ function () {
 
 exports.State = State;
 exports.bindActionToState = bindActionToState;
+exports.isState = isState;
 exports.isStateConfig = isStateConfig;
 exports.stateValuesEqual = stateValuesEqual;

package/lib/StateNode.js

@@ -3,15 +3,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
+var utils = require('./utils.js');
 var types = require('./types.js');
+var State = require('./State.js');
 var actionTypes = require('./actionTypes.js');
-var constants = require('./constants.js');
-var environment = require('./environment.js');
-var utils = require('./utils.js');
 var actions = require('./actions.js');
-var Actor = require('./Actor.js');
+var environment = require('./environment.js');
+var constants = require('./constants.js');
 var stateUtils = require('./stateUtils.js');
-var State = require('./State.js');
+var Actor = require('./Actor.js');
 var invokeUtils = require('./invokeUtils.js');
 
 var NULL_EVENT = '';

package/lib/actions.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('./_virtual/_tslib.js');
 var types = require('./types.js');
 var actionTypes = require('./actionTypes.js');
-var environment = require('./environment.js');
 var utils = require('./utils.js');
+var environment = require('./environment.js');
 
 var initEvent = /*#__PURE__*/utils.toSCXMLEvent({
   type: actionTypes.init

package/lib/behaviors.js

@@ -2,12 +2,78 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('./types.js');
-require('./actionTypes.js');
-require('./environment.js');
-var utils = require('./utils.js');
+var actions = require('./actions.js');
 var Actor = require('./Actor.js');
+var utils = require('./utils.js');
+
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+
+function fromReducer(transition, initialState) {
+  return {
+    transition: transition,
+    initialState: initialState
+  };
+}
+function fromPromise(promiseFn) {
+  var initialState = {
+    error: undefined,
+    data: undefined,
+    status: 'pending'
+  };
+  return {
+    transition: function (state, event, _a) {
+      var parent = _a.parent,
+          id = _a.id,
+          observers = _a.observers;
 
+      switch (event.type) {
+        case 'fulfill':
+          parent === null || parent === void 0 ? void 0 : parent.send(actions.doneInvoke(id, event.data));
+          return {
+            error: undefined,
+            data: event.data,
+            status: 'fulfilled'
+          };
+
+        case 'reject':
+          parent === null || parent === void 0 ? void 0 : parent.send(actions.error(id, event.error));
+          observers.forEach(function (observer) {
+            observer.error(event.error);
+          });
+          return {
+            error: event.error,
+            data: undefined,
+            status: 'rejected'
+          };
+
+        default:
+          return state;
+      }
+    },
+    initialState: initialState,
+    start: function (_a) {
+      var self = _a.self;
+      promiseFn().then(function (data) {
+        self.send({
+          type: 'fulfill',
+          data: data
+        });
+      }, function (reason) {
+        self.send({
+          type: 'reject',
+          error: reason
+        });
+      });
+      return initialState;
+    }
+  };
+}
 function spawnBehavior(behavior, options) {
   if (options === void 0) {
     options = {};
@@ -66,4 +132,6 @@ function spawnBehavior(behavior, options) {
   return actor;
 }
 
+exports.fromPromise = fromPromise;
+exports.fromReducer = fromReducer;
 exports.spawnBehavior = spawnBehavior;

package/lib/each.js

@@ -1,15 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.each = void 0;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
 function each(collection, item, indexOrActions, maybeActions) {
-    var actions = maybeActions || indexOrActions;
-    var index = maybeActions ? indexOrActions : undefined;
-    return {
-        type: 'xstate.foreach',
-        collection: collection,
-        item: item,
-        index: index,
-        actions: actions
-    };
+  var actions = maybeActions || indexOrActions;
+  var index = maybeActions ? indexOrActions : undefined;
+  return {
+    type: 'xstate.foreach',
+    collection: collection,
+    item: item,
+    index: index,
+    actions: actions
+  };
 }
+
 exports.each = each;