xstate 4.30.3 → 4.30.6

package/es/interpreter.js

@@ -1,16 +1,16 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
 import { ActionTypes, SpecialTargets } from './types.js';
+import { isStateConfig, State, bindActionToState } from './State.js';
 import { errorPlatform, log, stop, start, cancel, send, update, error as error$1 } from './actionTypes.js';
+import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
 import { IS_PRODUCTION } from './environment.js';
 import { warn, mapContext, isFunction, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
-import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
-import { provide, consume } from './serviceScope.js';
+import { Scheduler } from './scheduler.js';
 import { isSpawnedActor, createDeferredActor } from './Actor.js';
 import { isInFinalState } from './stateUtils.js';
-import { isStateConfig, State, bindActionToState } from './State.js';
-import { Scheduler } from './scheduler.js';
 import { registry } from './registry.js';
-import { registerService, getGlobal } from './devTools.js';
+import { getGlobal, registerService } from './devTools.js';
+import { provide, consume } from './serviceScope.js';
 import { spawnBehavior } from './behaviors.js';
 
 var DEFAULT_SPAWN_OPTIONS = {
@@ -24,8 +24,6 @@ var InterpreterStatus;
   InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
   InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
 })(InterpreterStatus || (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__*/
@@ -455,7 +453,13 @@ function () {
     if (this.status === 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.register(this.sessionId, this);
     this.initialized = true;
@@ -1310,8 +1314,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[symbolObservable] = function () {
     return this;
@@ -1332,23 +1334,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/es/invokeUtils.js

@@ -1,8 +1,8 @@
 import { __assign, __rest } from './_virtual/_tslib.js';
 import './types.js';
 import { invoke } from './actionTypes.js';
-import './environment.js';
 import './utils.js';
+import './environment.js';
 
 function toInvokeSource(src) {
   if (typeof src === 'string') {
@@ -25,9 +25,9 @@ function toInvokeDefinition(invokeConfig) {
     type: invoke
   }, invokeConfig), {
     toJSON: function () {
-      var onDone = invokeConfig.onDone,
-          onError = invokeConfig.onError,
-          invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
+      invokeConfig.onDone;
+          invokeConfig.onError;
+          var invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
 
       return __assign(__assign({}, invokeDef), {
         type: invoke,

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/types.d.ts

@@ -526,7 +526,7 @@ export declare type InternalMachineOptions<TContext, TEvent extends EventObject,
     activities?: Record<string, ActivityConfig<TContext, TEvent>>;
 };
 export declare type MachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>;
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<NoInfer<TContext>, TStateSchema, TEvent, TAction> {
+export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<NoInfer<TContext>, TStateSchema, NoInfer<TEvent>, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -572,7 +572,7 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, TEvent, TAction, TServiceMap>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
+}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TServiceMap>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
     id: string;
     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>;
@@ -1011,9 +1011,9 @@ export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventOb
      */
     state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
 };
-export declare type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : R extends Promise<infer U> ? ActorRef<never, U> : R extends Behavior<infer TEvent, infer TEmitted> ? ActorRef<TEvent, TEmitted> : never : never;
+export declare type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, MarkAllImplementationsAsProvided<TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRef<never, U> : R extends Behavior<infer TEvent, infer TEmitted> ? ActorRef<TEvent, TEmitted> : never : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any, any>;
-export declare type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : never;
+export declare type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, MarkAllImplementationsAsProvided<TResolvedTypesMeta>> : never;
 export declare type MachineOptionsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, any, infer TEvent, any, any, any, infer TResolvedTypesMeta> ? InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export declare type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
 export interface ActorContext<TEvent extends EventObject, TEmitted> {
@@ -1028,10 +1028,10 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
 }
 export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
-declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ___, infer ____, infer _____, infer ______> ? TEvent : R extends Model<infer _, infer TEvent, infer __, infer ___> ? TEvent : R extends State<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ___, infer ____> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export declare type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : Extract<TEvent, {
     type: K;
 }>;
-export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___> ? TContext : never : never;
+export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____, infer _____, infer ______> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : never : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/utils.d.ts

@@ -3,6 +3,7 @@ import { StateNode } from './StateNode';
 import { State } from './State';
 import { Actor } from './Actor';
 import { AnyStateMachine } from '.';
+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 getActionType(action: Action<any, any>): ActionType;

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;