xstate 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/{actions-1e9778c2.cjs.dev.js → actions-96f799fc.cjs.dev.js}

@@ -346,14 +346,21 @@ function toArray(value) {
 }
 function mapContext(mapper, context, _event) {
   if (isFunction(mapper)) {
-    return mapper(context, _event.data);
+    return mapper({
+      context: context,
+      event: _event.data
+    });
   }
   var result = {};
+  var args = {
+    context: context,
+    event: _event.data
+  };
   for (var _i4 = 0, _Object$keys2 = Object.keys(mapper); _i4 < _Object$keys2.length; _i4++) {
     var _key3 = _Object$keys2[_i4];
     var subMapper = mapper[_key3];
     if (isFunction(subMapper)) {
-      result[_key3] = subMapper(context, _event.data);
+      result[_key3] = subMapper(args);
     } else {
       result[_key3] = subMapper;
     }
@@ -518,24 +525,25 @@ function send$1(eventOrExpr, options) {
       // there is too big chance of the ID collision
       id: options && options.id !== undefined ? options.id : isFunction(eventOrExpr) ? eventOrExpr.name : eventOrExpr.type
     };
-    var meta = {
+    var args = {
+      context: state.context,
+      event: _event.data,
       _event: _event,
-      state: state,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : null,
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     };
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
-    var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(state.context, _event.data, meta) : eventOrExpr);
+    var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (isString(params.delay)) {
       var configDelay = delaysMap && delaysMap[params.delay];
-      resolvedDelay = isFunction(configDelay) ? configDelay(state.context, _event.data, meta) : configDelay;
+      resolvedDelay = isFunction(configDelay) ? configDelay(args) : configDelay;
     } else {
-      resolvedDelay = isFunction(params.delay) ? params.delay(state.context, _event.data, meta) : params.delay;
+      resolvedDelay = isFunction(params.delay) ? params.delay(args) : params.delay;
     }
-    var resolvedTarget = isFunction(params.to) ? params.to(state.context, _event.data, meta) : params.to;
+    var resolvedTarget = isFunction(params.to) ? params.to(args) : params.to;
     var targetActorRef;
     if (typeof resolvedTarget === 'string') {
       if (resolvedTarget === exports.SpecialTargets.Parent) {
@@ -607,7 +615,7 @@ function sendParent(event, options) {
  */
 function respond(event, options) {
   return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
-    to: function to(_, __, _ref2) {
+    to: function to(_ref2) {
       var _event = _ref2._event;
       return _event.origin; // TODO: handle when _event.origin is undefined
     }
@@ -631,7 +639,8 @@ function forwardTo(target, options) {
       return resolvedTarget;
     };
   }
-  return send$1(function (_, event) {
+  return send$1(function (_ref3) {
+    var event = _ref3.event;
     return event;
   }, _objectSpread2(_objectSpread2({}, options), {}, {
     to: target
@@ -646,10 +655,10 @@ function forwardTo(target, options) {
  * @param options Options to pass into the send action creator.
  */
 function escalate(errorData, options) {
-  return sendParent(function (context, event, meta) {
+  return sendParent(function (arg) {
     return {
       type: error,
-      data: isFunction(errorData) ? errorData(context, event, meta) : errorData
+      data: isFunction(errorData) ? errorData(arg) : errorData
     };
   }, _objectSpread2(_objectSpread2({}, options), {}, {
     to: exports.SpecialTargets.Parent
@@ -694,6 +703,86 @@ function _createClass(Constructor, protoProps, staticProps) {
   return Constructor;
 }
 
+var Mailbox = /*#__PURE__*/function () {
+  function Mailbox(_process) {
+    _classCallCheck(this, Mailbox);
+    this._process = _process;
+    _defineProperty(this, "_active", false);
+    _defineProperty(this, "_current", null);
+    _defineProperty(this, "_last", null);
+  }
+  _createClass(Mailbox, [{
+    key: "start",
+    value: function start() {
+      this._active = true;
+      this.flush();
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      // we can't set _current to null because we might be currently processing
+      // and enqueue following clear shouldnt start processing the enqueued item immediately
+      if (this._current) {
+        this._current.next = null;
+        this._last = this._current;
+      }
+    }
+
+    // TODO: rethink this design
+  }, {
+    key: "prepend",
+    value: function prepend(event) {
+      if (!this._current) {
+        this.enqueue(event);
+        return;
+      }
+
+      // we know that something is already queued up
+      // so the mailbox is already flushing or it's inactive
+      // therefore the only thing that we need to do is to reassign `this._current`
+      this._current = {
+        value: event,
+        next: this._current
+      };
+    }
+  }, {
+    key: "enqueue",
+    value: function enqueue(event) {
+      var enqueued = {
+        value: event,
+        next: null
+      };
+      if (this._current) {
+        this._last.next = enqueued;
+        this._last = enqueued;
+        return;
+      }
+      this._current = enqueued;
+      this._last = enqueued;
+      if (this._active) {
+        this.flush();
+      }
+    }
+  }, {
+    key: "flush",
+    value: function flush() {
+      while (this._current) {
+        // atm the given _process is responsible for implementing proper try/catch handling
+        // we assume here that this won't throw in a way that can affect this mailbox
+        var consumed = this._current;
+        this._process(consumed.value);
+        // something could have been prepended in the meantime
+        // so we need to be defensive here to avoid skipping over a prepended item
+        if (consumed === this._current) {
+          this._current = this._current.next;
+        }
+      }
+      this._last = null;
+    }
+  }]);
+  return Mailbox;
+}();
+
 var symbolObservable = function () {
   return typeof Symbol === 'function' && Symbol.observable || '@@observable';
 }();
@@ -1159,86 +1248,6 @@ function toActorRef(actorRefLike) {
   }), _objectSpread2$1), actorRefLike);
 }
 
-var Mailbox = /*#__PURE__*/function () {
-  function Mailbox(_process) {
-    _classCallCheck(this, Mailbox);
-    this._process = _process;
-    _defineProperty(this, "_active", false);
-    _defineProperty(this, "_current", null);
-    _defineProperty(this, "_last", null);
-  }
-  _createClass(Mailbox, [{
-    key: "start",
-    value: function start() {
-      this._active = true;
-      this.flush();
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      // we can't set _current to null because we might be currently processing
-      // and enqueue following clear shouldnt start processing the enqueued item immediately
-      if (this._current) {
-        this._current.next = null;
-        this._last = this._current;
-      }
-    }
-
-    // TODO: rethink this design
-  }, {
-    key: "prepend",
-    value: function prepend(event) {
-      if (!this._current) {
-        this.enqueue(event);
-        return;
-      }
-
-      // we know that something is already queued up
-      // so the mailbox is already flushing or it's inactive
-      // therefore the only thing that we need to do is to reassign `this._current`
-      this._current = {
-        value: event,
-        next: this._current
-      };
-    }
-  }, {
-    key: "enqueue",
-    value: function enqueue(event) {
-      var enqueued = {
-        value: event,
-        next: null
-      };
-      if (this._current) {
-        this._last.next = enqueued;
-        this._last = enqueued;
-        return;
-      }
-      this._current = enqueued;
-      this._last = enqueued;
-      if (this._active) {
-        this.flush();
-      }
-    }
-  }, {
-    key: "flush",
-    value: function flush() {
-      while (this._current) {
-        // atm the given _process is responsible for implementing proper try/catch handling
-        // we assume here that this won't throw in a way that can affect this mailbox
-        var consumed = this._current;
-        this._process(consumed.value);
-        // something could have been prepended in the meantime
-        // so we need to be defensive here to avoid skipping over a prepended item
-        if (consumed === this._current) {
-          this._current = this._current.next;
-        }
-      }
-      this._last = null;
-    }
-  }]);
-  return Mailbox;
-}();
-
 function createSystem() {
   var sessionIdCounter = 0;
   var children = new Map();
@@ -1742,7 +1751,10 @@ function stop$1(actorRef) {
     }
   }, function (_event, _ref) {
     var state = _ref.state;
-    var actorRefOrString = isFunction(actor) ? actor(state.context, _event.data) : actor;
+    var actorRefOrString = isFunction(actor) ? actor({
+      context: state.context,
+      event: _event.data
+    }) : actor;
     var actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
     return [state, {
       type: 'xstate.stop',
@@ -1765,7 +1777,9 @@ function stop$1(actorRef) {
   });
 }
 
-var defaultLogExpr = function defaultLogExpr(context, event) {
+var defaultLogExpr = function defaultLogExpr(_ref) {
+  var context = _ref.context,
+    event = _ref.event;
   return {
     context: context,
     event: event
@@ -1790,13 +1804,14 @@ function log$1() {
       label: label,
       expr: expr
     }
-  }, function (_event, _ref) {
+  }, function (_event, _ref2) {
     var _actorContext$self;
-    var state = _ref.state,
-      actorContext = _ref.actorContext;
-    var resolvedValue = typeof expr === 'function' ? expr(state.context, _event.data, {
+    var state = _ref2.state,
+      actorContext = _ref2.actorContext;
+    var resolvedValue = typeof expr === 'function' ? expr({
+      context: state.context,
+      event: _event.data,
       _event: _event,
-      state: state,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     }) : expr;
@@ -1837,10 +1852,10 @@ function cancel$1(sendId) {
     var _actorContext$self;
     var state = _ref.state,
       actorContext = _ref.actorContext;
-    var resolvedSendId = isFunction(sendId) ? sendId(state.context, _event.data, {
+    var resolvedSendId = isFunction(sendId) ? sendId({
+      context: state.context,
+      event: _event.data,
       _event: _event,
-      state: state,
-      // TODO: fix types,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     }) : sendId;
@@ -1904,7 +1919,7 @@ function stateIn(stateValue) {
     params: {
       stateValue: stateValue
     },
-    predicate: function predicate(_, __, _ref) {
+    predicate: function predicate(_ref) {
       var state = _ref.state;
       if (isString(stateValue) && isStateId(stateValue)) {
         return state.configuration.some(function (sn) {
@@ -1922,8 +1937,13 @@ function not(guard) {
       op: 'not'
     },
     children: [toGuardDefinition(guard)],
-    predicate: function predicate(ctx, _, meta) {
-      return !meta.evaluate(meta.guard.children[0], ctx, meta._event, meta.state);
+    predicate: function predicate(_ref2) {
+      var evaluate = _ref2.evaluate,
+        guard = _ref2.guard,
+        context = _ref2.context,
+        _event = _ref2._event,
+        state = _ref2.state;
+      return !evaluate(guard.children[0], context, _event, state);
     }
   };
 }
@@ -1936,9 +1956,14 @@ function and(guards) {
     children: guards.map(function (guard) {
       return toGuardDefinition(guard);
     }),
-    predicate: function predicate(ctx, _, meta) {
-      return meta.guard.children.every(function (childGuard) {
-        return meta.evaluate(childGuard, ctx, meta._event, meta.state);
+    predicate: function predicate(_ref3) {
+      var evaluate = _ref3.evaluate,
+        guard = _ref3.guard,
+        context = _ref3.context,
+        _event = _ref3._event,
+        state = _ref3.state;
+      return guard.children.every(function (childGuard) {
+        return evaluate(childGuard, context, _event, state);
       });
     }
   };
@@ -1952,9 +1977,14 @@ function or(guards) {
     children: guards.map(function (guard) {
       return toGuardDefinition(guard);
     }),
-    predicate: function predicate(ctx, _, meta) {
-      return meta.guard.children.some(function (childGuard) {
-        return meta.evaluate(childGuard, ctx, meta._event, meta.state);
+    predicate: function predicate(_ref4) {
+      var evaluate = _ref4.evaluate,
+        guard = _ref4.guard,
+        context = _ref4.context,
+        _event = _ref4._event,
+        state = _ref4.state;
+      return guard.children.some(function (childGuard) {
+        return evaluate(childGuard, context, _event, state);
       });
     }
   };
@@ -1962,17 +1992,18 @@ function or(guards) {
 function evaluateGuard(guard, context, _event, state) {
   var _machine$options$guar, _machine$options, _machine$options$guar2;
   var machine = state.machine;
-  var guardMeta = {
-    state: state,
-    guard: guard,
-    _event: _event,
-    evaluate: evaluateGuard
-  };
   var predicate = (_machine$options$guar = machine === null || machine === void 0 ? void 0 : (_machine$options = machine.options) === null || _machine$options === void 0 ? void 0 : (_machine$options$guar2 = _machine$options.guards) === null || _machine$options$guar2 === void 0 ? void 0 : _machine$options$guar2[guard.type]) !== null && _machine$options$guar !== void 0 ? _machine$options$guar : guard.predicate;
   if (!predicate) {
     throw new Error("Guard '".concat(guard.type, "' is not implemented.'."));
   }
-  return predicate(context, _event.data, guardMeta);
+  return predicate({
+    context: context,
+    event: _event.data,
+    state: state,
+    guard: guard,
+    _event: _event,
+    evaluate: evaluateGuard
+  });
 }
 function toGuardDefinition(guardConfig, getPredicate) {
   var _guardConfig$children;
@@ -3829,8 +3860,10 @@ function invoke$1(invokeDef) {
           src: src,
           parent: actorContext === null || actorContext === void 0 ? void 0 : actorContext.self,
           systemId: invokeDef.systemId,
-          input: typeof input === 'function' ? input(state.context, _event.data, {
-            self: actorContext.self
+          input: typeof input === 'function' ? input({
+            context: state.context,
+            event: _event.data,
+            self: actorContext === null || actorContext === void 0 ? void 0 : actorContext.self
           }) : input
         });
         resolvedInvokeAction = {
@@ -3887,7 +3920,9 @@ function createSpawner(self, machine, context, _event, mutCapturedActions) {
         var actorRef = interpret(referenced.src, {
           id: resolvedName,
           parent: self,
-          input: typeof input === 'function' ? input(context, _event.data, {
+          input: typeof input === 'function' ? input({
+            context: context,
+            event: _event.data,
             self: self
           }) : input
         });
@@ -3945,8 +3980,9 @@ function assign$1(assignment) {
     if (!state.context) {
       throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
     }
-    var meta = {
-      state: state,
+    var args = {
+      context: state.context,
+      event: _event.data,
       action: action,
       _event: _event,
       spawn: createSpawner(actorContext === null || actorContext === void 0 ? void 0 : actorContext.self, state.machine, state.context, _event, capturedActions),
@@ -3955,12 +3991,12 @@ function assign$1(assignment) {
     };
     var partialUpdate = {};
     if (isFunction(assignment)) {
-      partialUpdate = assignment(state.context, _event.data, meta);
+      partialUpdate = assignment(args);
     } else {
       for (var _i = 0, _Object$keys = Object.keys(assignment); _i < _Object$keys.length; _i++) {
         var key = _Object$keys[_i];
         var propAssignment = assignment[key];
-        partialUpdate[key] = isFunction(propAssignment) ? propAssignment(state.context, _event.data, meta) : propAssignment;
+        partialUpdate[key] = isFunction(propAssignment) ? propAssignment(args) : propAssignment;
       }
     }
     var updatedContext = Object.assign({}, state.context, partialUpdate);
@@ -4000,22 +4036,23 @@ function raise$1(eventOrExpr, options) {
       event: eventOrExpr,
       id: options && options.id !== undefined ? options.id : typeof eventOrExpr === 'function' ? eventOrExpr.name : eventOrExpr.type
     };
-    var meta = {
+    var args = {
+      context: state.context,
+      event: _event.data,
       _event: _event,
-      state: state,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     };
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
-    var resolvedEvent = toSCXMLEvent(typeof eventOrExpr === 'function' ? eventOrExpr(state.context, _event.data, meta) : eventOrExpr);
+    var resolvedEvent = toSCXMLEvent(typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (typeof params.delay === 'string') {
       var configDelay = delaysMap && delaysMap[params.delay];
-      resolvedDelay = typeof configDelay === 'function' ? configDelay(state.context, _event.data, meta) : configDelay;
+      resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
     } else {
-      resolvedDelay = typeof params.delay === 'function' ? params.delay(state.context, _event.data, meta) : params.delay;
+      resolvedDelay = typeof params.delay === 'function' ? params.delay(args) : params.delay;
     }
     var resolvedAction = {
       type: raise,
@@ -4078,10 +4115,11 @@ function resolveActionObject(actionObject, actionFunctionMap) {
         type: actionObject.type,
         params: actionObject.params,
         execute: function execute(actorCtx) {
-          return dereferencedAction(state.context, state.event, {
+          return dereferencedAction({
+            context: state.context,
+            event: state.event,
             action: a,
             _event: state._event,
-            state: state,
             system: actorCtx.system,
             self: actorCtx.self
           });
@@ -4118,10 +4156,11 @@ function toActionObject(action) {
           "function": action
         },
         execute: function execute(actorCtx) {
-          return action(state.context, _event.data, {
+          return action({
+            context: state.context,
+            event: _event.data,
             action: actionObject,
             _event: _event,
-            state: state,
             self: actorCtx.self,
             system: actorCtx.system
           });

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.js';
-import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.js';
-import { StateMachine } from './StateMachine.js';
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.ts';
+import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.ts';
+import { StateMachine } from './StateMachine.ts';
 export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>): StateMachine<TContext, TEvent, ParameterizedObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>;

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

@@ -1,4 +1,4 @@
-import { Clock } from './interpreter.js';
+import { Clock } from './interpreter.ts';
 export interface SimulatedClock extends Clock {
     start(speed: number): void;
     increment(ms: number): void;

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

@@ -1,6 +1,6 @@
-import type { StateNode } from './StateNode.js';
-import { TypegenDisabled, TypegenEnabled } from './typegenTypes.js';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.js';
+import type { StateNode } from './StateNode.ts';
+import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.ts';
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.

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

@@ -1,7 +1,7 @@
-import { State } from './State.js';
-import { StateNode } from './StateNode.js';
-import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.js';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, AnyActorContext, PersistedMachineState, ParameterizedObject } from './types.js';
+import { State } from './State.ts';
+import { StateNode } from './StateNode.ts';
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.js';
-import type { State } from './State.js';
-import type { StateMachine } from './StateMachine.js';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
+import type { State } from './State.ts';
+import type { StateMachine } from './StateMachine.ts';
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;

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

@@ -1,4 +1,4 @@
-import { ActionTypes } from './types.js';
+import { ActionTypes } from './types.ts';
 export declare const stop = ActionTypes.Stop;
 export declare const raise = ActionTypes.Raise;
 export declare const send = ActionTypes.Send;

package/dist/declarations/src/actions/assign.d.ts

@@ -1,4 +1,4 @@
-import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.js';
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.ts';
 /**
  * Updates the current context of the machine.
  *

package/dist/declarations/src/actions/cancel.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, ExprWithMeta, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.js';
+import { EventObject, ExprWithMeta, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.ts';
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent

package/dist/declarations/src/actions/choose.d.ts

@@ -1,3 +1,3 @@
-import { EventObject, ChooseCondition, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.js';
+import { EventObject, ChooseCondition, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.ts';
 export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TExpressionEvent>>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, ResolvedChooseAction, ChooseAction<TContext, TExpressionEvent>['params']>;

package/dist/declarations/src/actions/invoke.d.ts

@@ -1,3 +1,3 @@
-import { EventObject, InvokeDefinition, MachineContext } from '../types.js';
-import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '../index.js';
+import { EventObject, InvokeDefinition, MachineContext } from '../types.ts';
+import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '../index.ts';
 export declare function invoke<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(invokeDef: InvokeDefinition<TContext, TEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, InvokeActionObject, DynamicInvokeActionObject<TContext, TEvent>['params']>;

package/dist/declarations/src/actions/log.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.js';
-import { BaseDynamicActionObject, DynamicLogAction } from '../index.js';
+import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.ts';
+import { BaseDynamicActionObject, DynamicLogAction } from '../index.ts';
 /**
  *
  * @param expr The expression function to evaluate which will be logged.

package/dist/declarations/src/actions/pure.d.ts

@@ -1,3 +1,6 @@
-import { EventObject, SingleOrArray, MachineContext } from '../types.js';
+import { EventObject, SingleOrArray, MachineContext } from '../types.ts';
 import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from '..';
-export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: (context: TContext, event: TExpressionEvent) => SingleOrArray<BaseActionObject | string> | undefined): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, PureActionObject, DynamicPureActionObject<TContext, TExpressionEvent>['params']>;
+export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: ({ context, event }: {
+    context: TContext;
+    event: TExpressionEvent;
+}) => SingleOrArray<BaseActionObject | string> | undefined): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, PureActionObject, DynamicPureActionObject<TContext, TExpressionEvent>['params']>;

package/dist/declarations/src/actions/raise.d.ts

@@ -1,4 +1,4 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.js';
+import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.ts';
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.

package/dist/declarations/src/actions/send.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.js';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.js';
+import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.ts';
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.ts';
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.

package/dist/declarations/src/actions/stop.d.ts

@@ -1,4 +1,4 @@
-import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.js';
+import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.ts';
 /**
  * Stops an actor.
  *