xstate 4.30.2 → 4.30.5

package/es/behaviors.js

@@ -1,9 +1,75 @@
-import './environment.js';
-import { toObserver } from './utils.js';
-import './types.js';
-import './actionTypes.js';
+import { error, doneInvoke } from './actions.js';
 import { toActorRef } from './Actor.js';
+import { toObserver } from './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(doneInvoke(id, event.data));
+          return {
+            error: undefined,
+            data: event.data,
+            status: 'fulfilled'
+          };
+
+        case 'reject':
+          parent === null || parent === void 0 ? void 0 : parent.send(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 = {};
@@ -62,4 +128,4 @@ function spawnBehavior(behavior, options) {
   return actor;
 }
 
-export { spawnBehavior };
+export { fromPromise, fromReducer, spawnBehavior };

package/es/each.js

@@ -0,0 +1,13 @@
+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
+  };
+}
+
+export { each };

package/es/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/es/index.js

@@ -1,16 +1,17 @@
-export { matchesState } from './utils.js';
-export { mapState } from './mapState.js';
-export { ActionTypes, SpecialTargets } from './types.js';
 import { assign as assign$1, send as send$1, sendParent as sendParent$1, sendUpdate as sendUpdate$1, forwardTo as forwardTo$1, doneInvoke as doneInvoke$1 } from './actions.js';
 import * as actions from './actions.js';
 export { actions };
-export { State } from './State.js';
 export { toActorRef } from './Actor.js';
-export { StateNode } from './StateNode.js';
-export { Machine, createMachine } from './Machine.js';
 export { Interpreter, InterpreterStatus, interpret, spawn } from './interpreter.js';
+export { Machine, createMachine } from './Machine.js';
+export { mapState } from './mapState.js';
 export { matchState } from './match.js';
 export { createSchema, t } from './schema.js';
+export { State } from './State.js';
+export { StateNode } from './StateNode.js';
+export { spawnBehavior } from './behaviors.js';
+export { ActionTypes, SpecialTargets } from './types.js';
+export { matchesState, toEventObject, toObserver, toSCXMLEvent } from './utils.js';
 
 var assign = assign$1,
     send = send$1,

package/es/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/es/interpreter.js

@@ -1,16 +1,16 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
-import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
 import { ActionTypes, SpecialTargets } from './types.js';
-import { isInFinalState } from './stateUtils.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 { isStateConfig, State, bindActionToState } from './State.js';
-import { provide, consume } from './serviceScope.js';
-import { isSpawnedActor, createDeferredActor } from './Actor.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 { Scheduler } from './scheduler.js';
+import { isSpawnedActor, createDeferredActor } from './Actor.js';
+import { isInFinalState } from './stateUtils.js';
 import { registry } from './registry.js';
 import { registerService, getGlobal } from './devTools.js';
+import { provide, consume } from './serviceScope.js';
 import { spawnBehavior } from './behaviors.js';
 
 var DEFAULT_SPAWN_OPTIONS = {
@@ -24,6 +24,8 @@ 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__*/
@@ -591,7 +593,7 @@ function () {
 
     try {
       // Cancel all delayed events
-      for (var _p = __values(keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
+      for (var _p = __values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
         var key = _q.value;
         this.clock.clearTimeout(this.delayedEventsMap[key]);
       }
@@ -1308,6 +1310,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[symbolObservable] = function () {
     return this;

package/es/invokeUtils.js

@@ -1,8 +1,8 @@
 import { __assign, __rest } from './_virtual/_tslib.js';
-import './environment.js';
-import './utils.js';
 import './types.js';
 import { invoke } from './actionTypes.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/mapState.js

@@ -1,5 +1,5 @@
 import { __values } from './_virtual/_tslib.js';
-import { keys, matchesState } from './utils.js';
+import { matchesState } from './utils.js';
 
 function mapState(stateMap, stateId) {
   var e_1, _a;
@@ -7,7 +7,7 @@ function mapState(stateMap, stateId) {
   var foundStateId;
 
   try {
-    for (var _b = __values(keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+    for (var _b = __values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
       var mappedStateId = _c.value;
 
       if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {

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

@@ -1,11 +1,11 @@
 import { __values, __spreadArray, __read } from './_virtual/_tslib.js';
-import { flatten, keys } from './utils.js';
+import { flatten } from './utils.js';
 
 var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
 };
 function getChildren(stateNode) {
-  return keys(stateNode.states).map(function (key) {
+  return Object.keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
   });
 }

package/es/types.d.ts

@@ -22,6 +22,8 @@ export declare type IndexByType<T extends {
 export declare type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export declare type IsAny<T> = Equals<T, any>;
 export declare type Cast<A, B> = A extends B ? A : B;
+export declare type NoInfer<T> = [T][T extends any ? 0 : any];
+export declare type LowInfer<T> = T & {};
 export declare type EventType = string;
 export declare type ActionType = string;
 export declare type MetaObject = Record<string, any>;
@@ -524,11 +526,11 @@ 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<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, TEvent, TAction> {
     /**
      * The initial context (extended state)
      */
-    context?: TContext | (() => TContext);
+    context?: LowInfer<TContext | (() => TContext)>;
     /**
      * The machine's own version.
      */
@@ -1009,7 +1011,7 @@ export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventOb
      */
     state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
 };
-export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, any> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : 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, 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 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;
@@ -1026,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

@@ -11,9 +11,7 @@ export declare function toStatePath(stateId: string | string[], delimiter: strin
 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<T, P, O extends {
-    [key: string]: T;
-}>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
+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: {