xstate 4.32.1 → 5.0.0-alpha.0

package/dist/declarations/src/utils.d.ts

@@ -0,0 +1,56 @@
+import { NULL_EVENT } from './constants';
+import type { StateNode } from './StateNode';
+import type { Behavior, BehaviorCreator, Event, EventObject, EventType, InvokeConfig, InvokeSourceDefinition, MachineContext, Mapper, Observer, PropertyMapper, SCXML, SCXMLErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from './types';
+import { AnyStateMachine } from './types';
+export declare function keys<T extends object>(value: T): Array<keyof T & string>;
+export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
+export declare function getEventType<TEvent extends EventObject = EventObject>(event: Event<TEvent>): TEvent['type'];
+export declare function toStatePath(stateId: string | string[], delimiter: string): string[];
+export declare function isStateLike(state: any): state is StateLike<any>;
+export declare function toStateValue(stateValue: StateLike<any> | StateValue | string[], delimiter: string): StateValue;
+export declare function pathToStateValue(statePath: string[]): StateValue;
+export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
+    [key in keyof O]: P;
+};
+export declare function mapFilterValues<T, P>(collection: {
+    [key: string]: T;
+}, iteratee: (item: T, key: string, collection: {
+    [key: string]: T;
+}) => P, predicate: (item: T) => boolean): {
+    [key: string]: P;
+};
+/**
+ * Retrieves a value at the given path.
+ * @param props The deep path to the prop of the desired value
+ */
+export declare function path<T extends Record<string, any>>(props: string[]): any;
+export declare function toStatePaths(stateValue: StateValue | undefined): string[][];
+export declare function flatten<T>(array: Array<T | T[]>): T[];
+export declare function toArrayStrict<T>(value: T[] | T): T[];
+export declare function toArray<T>(value: T[] | T | undefined): T[];
+export declare function mapContext<TContext extends MachineContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>, context: TContext, _event: SCXML.Event<TEvent>): any;
+export declare function isBuiltInEvent(eventType: EventType): boolean;
+export declare function isPromiseLike(value: any): value is PromiseLike<any>;
+export declare function isBehavior(value: any): value is Behavior<any, any>;
+export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
+export declare let warn: (condition: boolean | Error, message: string) => void;
+export declare function isArray(value: any): value is any[];
+export declare function isFunction(value: any): value is Function;
+export declare function isString(value: any): value is string;
+export declare function isObservable<T>(value: any): value is Subscribable<T>;
+export declare const symbolObservable: typeof Symbol.observable;
+export declare function isStateMachine(value: any): value is AnyStateMachine;
+export declare const uniqueId: () => string;
+export declare function toEventObject<TEvent extends EventObject>(event: Event<TEvent>, payload?: Record<string, any>): TEvent;
+export declare function isSCXMLEvent<TEvent extends EventObject>(event: Event<TEvent> | SCXML.Event<TEvent>): event is SCXML.Event<TEvent>;
+export declare function isSCXMLErrorEvent(event: SCXML.Event<any>): event is SCXMLErrorEvent;
+export declare function toSCXMLEvent<TEvent extends EventObject>(event: Event<TEvent> | SCXML.Event<TEvent>, scxmlEvent?: Partial<SCXML.Event<TEvent>>): SCXML.Event<TEvent>;
+export declare function toTransitionConfigArray<TContext extends MachineContext, TEvent extends EventObject>(event: TEvent['type'] | typeof NULL_EVENT | '*', configLike: SingleOrArray<TransitionConfig<TContext, TEvent> | TransitionConfigTarget<TContext, TEvent>>): Array<TransitionConfig<TContext, TEvent> & {
+    event: TEvent['type'] | typeof NULL_EVENT | '*';
+}>;
+export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): Array<string | StateNode<TContext, TEvent>> | undefined;
+export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
+export declare function toInvokeConfig<TContext extends MachineContext, TEvent extends EventObject>(invocable: InvokeConfig<TContext, TEvent> | string | BehaviorCreator<TContext, TEvent> | Behavior<any, any>, id: string): InvokeConfig<TContext, TEvent>;
+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;

package/{es/devTools.js → dist/index-20b364c4.esm.js}

@@ -1,5 +1,6 @@
-import { IS_PRODUCTION } from './environment.js';
+var IS_PRODUCTION = process.env.NODE_ENV === 'production';
 
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
 function getGlobal() {
   if (typeof globalThis !== 'undefined') {
     return globalThis;
@@ -23,17 +24,17 @@ function getGlobal() {
 }
 
 function getDevTools() {
-  var global = getGlobal();
+  var w = getGlobal();
 
-  if (global && '__xstate__' in global) {
-    return global.__xstate__;
+  if (!!w.__xstate__) {
+    return w.__xstate__;
   }
 
   return undefined;
 }
 
 function registerService(service) {
-  if (!getGlobal()) {
+  if (typeof window === 'undefined') {
     return;
   }
 
@@ -43,5 +44,16 @@ function registerService(service) {
     devTools.register(service);
   }
 }
+var devToolsAdapter = function devToolsAdapter(service) {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  var devTools = getDevTools();
+
+  if (devTools) {
+    devTools.register(service);
+  }
+};
 
-export { getGlobal, registerService };
+export { IS_PRODUCTION as I, devToolsAdapter as d, getGlobal as g, registerService as r };

package/dist/index-2a564d03.cjs.dev.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var IS_PRODUCTION = process.env.NODE_ENV === 'production';
+
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+function getGlobal() {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  }
+
+  if (typeof self !== 'undefined') {
+    return self;
+  }
+
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+
+  if (typeof global !== 'undefined') {
+    return global;
+  }
+
+  if (!IS_PRODUCTION) {
+    console.warn('XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues');
+  }
+}
+
+function getDevTools() {
+  var w = getGlobal();
+
+  if (!!w.__xstate__) {
+    return w.__xstate__;
+  }
+
+  return undefined;
+}
+
+function registerService(service) {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  var devTools = getDevTools();
+
+  if (devTools) {
+    devTools.register(service);
+  }
+}
+var devToolsAdapter = function devToolsAdapter(service) {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  var devTools = getDevTools();
+
+  if (devTools) {
+    devTools.register(service);
+  }
+};
+
+exports.IS_PRODUCTION = IS_PRODUCTION;
+exports.devToolsAdapter = devToolsAdapter;
+exports.getGlobal = getGlobal;
+exports.registerService = registerService;

package/dist/xstate.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";

package/dist/xstate.cjs.dev.js

@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var guards_dist_xstateGuards = require('./actions-6b86876d.cjs.dev.js');
+require('./index-2a564d03.cjs.dev.js');
+var Machine = require('./Machine-9ce74c11.cjs.dev.js');
+
+function pure(getActions) {
+  return guards_dist_xstateGuards.createDynamicAction(guards_dist_xstateGuards.pure, {
+    get: getActions
+  }, function (_ref, ctx, _event) {
+    var _toArray;
+
+    var params = _ref.params;
+    return {
+      type: guards_dist_xstateGuards.pure,
+      params: {
+        actions: (_toArray = guards_dist_xstateGuards.toArray(params.get(ctx, _event.data))) !== null && _toArray !== void 0 ? _toArray : []
+      }
+    };
+  });
+}
+
+function mapState(stateMap, stateId) {
+  var foundStateId;
+
+  for (var _i = 0, _Object$keys = Object.keys(stateMap); _i < _Object$keys.length; _i++) {
+    var mappedStateId = _Object$keys[_i];
+
+    if (guards_dist_xstateGuards.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
+    }
+  }
+
+  return stateMap[foundStateId];
+}
+
+function matchState(state, patterns, defaultValue) {
+  var resolvedState = guards_dist_xstateGuards.State.from(state, state instanceof guards_dist_xstateGuards.State ? state.context : undefined);
+
+  var _iterator = guards_dist_xstateGuards._createForOfIteratorHelper(patterns),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = guards_dist_xstateGuards._slicedToArray(_step.value, 2),
+          stateValue = _step$value[0],
+          getValue = _step$value[1];
+
+      if (resolvedState.matches(stateValue)) {
+        return getValue(resolvedState);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return defaultValue(resolvedState);
+}
+
+function createSchema(schema) {
+  return schema;
+}
+var t = createSchema;
+
+var SimulatedClock = /*#__PURE__*/function () {
+  function SimulatedClock() {
+    guards_dist_xstateGuards._classCallCheck(this, SimulatedClock);
+
+    guards_dist_xstateGuards._defineProperty(this, "timeouts", new Map());
+
+    guards_dist_xstateGuards._defineProperty(this, "_now", 0);
+
+    guards_dist_xstateGuards._defineProperty(this, "_id", 0);
+  }
+
+  guards_dist_xstateGuards._createClass(SimulatedClock, [{
+    key: "now",
+    value: function now() {
+      return this._now;
+    }
+  }, {
+    key: "getId",
+    value: function getId() {
+      return this._id++;
+    }
+  }, {
+    key: "setTimeout",
+    value: function setTimeout(fn, timeout) {
+      var id = this.getId();
+      this.timeouts.set(id, {
+        start: this.now(),
+        timeout: timeout,
+        fn: fn
+      });
+      return id;
+    }
+  }, {
+    key: "clearTimeout",
+    value: function clearTimeout(id) {
+      this.timeouts["delete"](id);
+    }
+  }, {
+    key: "set",
+    value: function set(time) {
+      if (this._now > time) {
+        throw new Error('Unable to travel back in time');
+      }
+
+      this._now = time;
+      this.flushTimeouts();
+    }
+  }, {
+    key: "flushTimeouts",
+    value: function flushTimeouts() {
+      var _this = this;
+
+      guards_dist_xstateGuards._toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
+        var _ref3 = guards_dist_xstateGuards._slicedToArray(_ref, 2),
+            _idA = _ref3[0],
+            timeoutA = _ref3[1];
+
+        var _ref4 = guards_dist_xstateGuards._slicedToArray(_ref2, 2),
+            _idB = _ref4[0],
+            timeoutB = _ref4[1];
+
+        var endA = timeoutA.start + timeoutA.timeout;
+        var endB = timeoutB.start + timeoutB.timeout;
+        return endB > endA ? -1 : 1;
+      }).forEach(function (_ref5) {
+        var _ref6 = guards_dist_xstateGuards._slicedToArray(_ref5, 2),
+            id = _ref6[0],
+            timeout = _ref6[1];
+
+        if (_this.now() - timeout.start >= timeout.timeout) {
+          _this.timeouts["delete"](id);
+
+          timeout.fn.call(null);
+        }
+      });
+    }
+  }, {
+    key: "increment",
+    value: function increment(ms) {
+      this._now += ms;
+      this.flushTimeouts();
+    }
+  }]);
+
+  return SimulatedClock;
+}();
+
+var actions = {
+  raise: guards_dist_xstateGuards.raise,
+  send: guards_dist_xstateGuards.send,
+  sendParent: guards_dist_xstateGuards.sendParent,
+  sendTo: guards_dist_xstateGuards.sendTo,
+  sendUpdate: guards_dist_xstateGuards.sendUpdate,
+  log: guards_dist_xstateGuards.log,
+  cancel: guards_dist_xstateGuards.cancel,
+  stop: guards_dist_xstateGuards.stop,
+  assign: guards_dist_xstateGuards.assign,
+  after: guards_dist_xstateGuards.after,
+  done: guards_dist_xstateGuards.done,
+  respond: guards_dist_xstateGuards.respond,
+  forwardTo: guards_dist_xstateGuards.forwardTo,
+  escalate: guards_dist_xstateGuards.escalate,
+  choose: guards_dist_xstateGuards.choose,
+  pure: pure
+};
+
+Object.defineProperty(exports, 'ActionTypes', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.ActionTypes;
+  }
+});
+exports.Interpreter = guards_dist_xstateGuards.Interpreter;
+Object.defineProperty(exports, 'InterpreterStatus', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.InterpreterStatus;
+  }
+});
+exports.ObservableActorRef = guards_dist_xstateGuards.ObservableActorRef;
+Object.defineProperty(exports, 'SpecialTargets', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.SpecialTargets;
+  }
+});
+exports.State = guards_dist_xstateGuards.State;
+exports.assign = guards_dist_xstateGuards.assign;
+exports.doneInvoke = guards_dist_xstateGuards.doneInvoke;
+exports.forwardTo = guards_dist_xstateGuards.forwardTo;
+exports.getStateNodes = guards_dist_xstateGuards.getStateNodes;
+exports.interpret = guards_dist_xstateGuards.interpret;
+exports.matchesState = guards_dist_xstateGuards.matchesState;
+exports.pathToStateValue = guards_dist_xstateGuards.pathToStateValue;
+exports.send = guards_dist_xstateGuards.send;
+exports.sendParent = guards_dist_xstateGuards.sendParent;
+exports.sendUpdate = guards_dist_xstateGuards.sendUpdate;
+exports.toEventObject = guards_dist_xstateGuards.toEventObject;
+exports.toObserver = guards_dist_xstateGuards.toObserver;
+exports.toSCXMLEvent = guards_dist_xstateGuards.toSCXMLEvent;
+exports.StateMachine = Machine.StateMachine;
+exports.StateNode = Machine.StateNode;
+exports.createMachine = Machine.createMachine;
+exports.SimulatedClock = SimulatedClock;
+exports.actions = actions;
+exports.createSchema = createSchema;
+exports.mapState = mapState;
+exports.matchState = matchState;
+exports.t = t;

package/dist/xstate.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./xstate.cjs.prod.js");
+} else {
+  module.exports = require("./xstate.cjs.dev.js");
+}

package/dist/xstate.cjs.prod.js

@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var guards_dist_xstateGuards = require('./actions-70094c93.cjs.prod.js');
+require('../dev/dist/xstate-dev.cjs.prod.js');
+var Machine = require('./Machine-dca041dc.cjs.prod.js');
+
+function pure(getActions) {
+  return guards_dist_xstateGuards.createDynamicAction(guards_dist_xstateGuards.pure, {
+    get: getActions
+  }, function (_ref, ctx, _event) {
+    var _toArray;
+
+    var params = _ref.params;
+    return {
+      type: guards_dist_xstateGuards.pure,
+      params: {
+        actions: (_toArray = guards_dist_xstateGuards.toArray(params.get(ctx, _event.data))) !== null && _toArray !== void 0 ? _toArray : []
+      }
+    };
+  });
+}
+
+function mapState(stateMap, stateId) {
+  var foundStateId;
+
+  for (var _i = 0, _Object$keys = Object.keys(stateMap); _i < _Object$keys.length; _i++) {
+    var mappedStateId = _Object$keys[_i];
+
+    if (guards_dist_xstateGuards.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
+    }
+  }
+
+  return stateMap[foundStateId];
+}
+
+function matchState(state, patterns, defaultValue) {
+  var resolvedState = guards_dist_xstateGuards.State.from(state, state instanceof guards_dist_xstateGuards.State ? state.context : undefined);
+
+  var _iterator = guards_dist_xstateGuards._createForOfIteratorHelper(patterns),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = guards_dist_xstateGuards._slicedToArray(_step.value, 2),
+          stateValue = _step$value[0],
+          getValue = _step$value[1];
+
+      if (resolvedState.matches(stateValue)) {
+        return getValue(resolvedState);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return defaultValue(resolvedState);
+}
+
+function createSchema(schema) {
+  return schema;
+}
+var t = createSchema;
+
+var SimulatedClock = /*#__PURE__*/function () {
+  function SimulatedClock() {
+    guards_dist_xstateGuards._classCallCheck(this, SimulatedClock);
+
+    guards_dist_xstateGuards._defineProperty(this, "timeouts", new Map());
+
+    guards_dist_xstateGuards._defineProperty(this, "_now", 0);
+
+    guards_dist_xstateGuards._defineProperty(this, "_id", 0);
+  }
+
+  guards_dist_xstateGuards._createClass(SimulatedClock, [{
+    key: "now",
+    value: function now() {
+      return this._now;
+    }
+  }, {
+    key: "getId",
+    value: function getId() {
+      return this._id++;
+    }
+  }, {
+    key: "setTimeout",
+    value: function setTimeout(fn, timeout) {
+      var id = this.getId();
+      this.timeouts.set(id, {
+        start: this.now(),
+        timeout: timeout,
+        fn: fn
+      });
+      return id;
+    }
+  }, {
+    key: "clearTimeout",
+    value: function clearTimeout(id) {
+      this.timeouts["delete"](id);
+    }
+  }, {
+    key: "set",
+    value: function set(time) {
+      if (this._now > time) {
+        throw new Error('Unable to travel back in time');
+      }
+
+      this._now = time;
+      this.flushTimeouts();
+    }
+  }, {
+    key: "flushTimeouts",
+    value: function flushTimeouts() {
+      var _this = this;
+
+      guards_dist_xstateGuards._toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
+        var _ref3 = guards_dist_xstateGuards._slicedToArray(_ref, 2),
+            _idA = _ref3[0],
+            timeoutA = _ref3[1];
+
+        var _ref4 = guards_dist_xstateGuards._slicedToArray(_ref2, 2),
+            _idB = _ref4[0],
+            timeoutB = _ref4[1];
+
+        var endA = timeoutA.start + timeoutA.timeout;
+        var endB = timeoutB.start + timeoutB.timeout;
+        return endB > endA ? -1 : 1;
+      }).forEach(function (_ref5) {
+        var _ref6 = guards_dist_xstateGuards._slicedToArray(_ref5, 2),
+            id = _ref6[0],
+            timeout = _ref6[1];
+
+        if (_this.now() - timeout.start >= timeout.timeout) {
+          _this.timeouts["delete"](id);
+
+          timeout.fn.call(null);
+        }
+      });
+    }
+  }, {
+    key: "increment",
+    value: function increment(ms) {
+      this._now += ms;
+      this.flushTimeouts();
+    }
+  }]);
+
+  return SimulatedClock;
+}();
+
+var actions = {
+  raise: guards_dist_xstateGuards.raise,
+  send: guards_dist_xstateGuards.send,
+  sendParent: guards_dist_xstateGuards.sendParent,
+  sendTo: guards_dist_xstateGuards.sendTo,
+  sendUpdate: guards_dist_xstateGuards.sendUpdate,
+  log: guards_dist_xstateGuards.log,
+  cancel: guards_dist_xstateGuards.cancel,
+  stop: guards_dist_xstateGuards.stop,
+  assign: guards_dist_xstateGuards.assign,
+  after: guards_dist_xstateGuards.after,
+  done: guards_dist_xstateGuards.done,
+  respond: guards_dist_xstateGuards.respond,
+  forwardTo: guards_dist_xstateGuards.forwardTo,
+  escalate: guards_dist_xstateGuards.escalate,
+  choose: guards_dist_xstateGuards.choose,
+  pure: pure
+};
+
+Object.defineProperty(exports, 'ActionTypes', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.ActionTypes;
+  }
+});
+exports.Interpreter = guards_dist_xstateGuards.Interpreter;
+Object.defineProperty(exports, 'InterpreterStatus', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.InterpreterStatus;
+  }
+});
+exports.ObservableActorRef = guards_dist_xstateGuards.ObservableActorRef;
+Object.defineProperty(exports, 'SpecialTargets', {
+  enumerable: true,
+  get: function () {
+    return guards_dist_xstateGuards.SpecialTargets;
+  }
+});
+exports.State = guards_dist_xstateGuards.State;
+exports.assign = guards_dist_xstateGuards.assign;
+exports.doneInvoke = guards_dist_xstateGuards.doneInvoke;
+exports.forwardTo = guards_dist_xstateGuards.forwardTo;
+exports.getStateNodes = guards_dist_xstateGuards.getStateNodes;
+exports.interpret = guards_dist_xstateGuards.interpret;
+exports.matchesState = guards_dist_xstateGuards.matchesState;
+exports.pathToStateValue = guards_dist_xstateGuards.pathToStateValue;
+exports.send = guards_dist_xstateGuards.send;
+exports.sendParent = guards_dist_xstateGuards.sendParent;
+exports.sendUpdate = guards_dist_xstateGuards.sendUpdate;
+exports.toEventObject = guards_dist_xstateGuards.toEventObject;
+exports.toObserver = guards_dist_xstateGuards.toObserver;
+exports.toSCXMLEvent = guards_dist_xstateGuards.toSCXMLEvent;
+exports.StateMachine = Machine.StateMachine;
+exports.StateNode = Machine.StateNode;
+exports.createMachine = Machine.createMachine;
+exports.SimulatedClock = SimulatedClock;
+exports.actions = actions;
+exports.createSchema = createSchema;
+exports.mapState = mapState;
+exports.matchState = matchState;
+exports.t = t;