xstate 4.31.0 → 5.0.0-alpha.0

package/es/actions.js

@@ -1,520 +0,0 @@
-import { __assign, __read, __spreadArray } from './_virtual/_tslib.js';
-import { SpecialTargets, ActionTypes } from './types.js';
-import { init, send as send$1, raise as raise$1, update, log as log$1, cancel as cancel$1, assign as assign$1, error as error$1, stop as stop$1, pure as pure$1, choose as choose$1 } from './actionTypes.js';
-import * as actionTypes from './actionTypes.js';
-export { actionTypes };
-import { toSCXMLEvent, isString, isFunction, toEventObject, getEventType, partition, updateContext, flatten, toArray, toGuard, evaluateGuard, warn, isArray } from './utils.js';
-import { IS_PRODUCTION } from './environment.js';
-
-var initEvent = /*#__PURE__*/toSCXMLEvent({
-  type: init
-});
-function getActionFunction(actionType, actionFunctionMap) {
-  return actionFunctionMap ? actionFunctionMap[actionType] || undefined : undefined;
-}
-function toActionObject(action, actionFunctionMap) {
-  var actionObject;
-
-  if (isString(action) || typeof action === 'number') {
-    var exec = getActionFunction(action, actionFunctionMap);
-
-    if (isFunction(exec)) {
-      actionObject = {
-        type: action,
-        exec: exec
-      };
-    } else if (exec) {
-      actionObject = exec;
-    } else {
-      actionObject = {
-        type: action,
-        exec: undefined
-      };
-    }
-  } else if (isFunction(action)) {
-    actionObject = {
-      // Convert action to string if unnamed
-      type: action.name || action.toString(),
-      exec: action
-    };
-  } else {
-    var exec = getActionFunction(action.type, actionFunctionMap);
-
-    if (isFunction(exec)) {
-      actionObject = __assign(__assign({}, action), {
-        exec: exec
-      });
-    } else if (exec) {
-      var actionType = exec.type || action.type;
-      actionObject = __assign(__assign(__assign({}, exec), action), {
-        type: actionType
-      });
-    } else {
-      actionObject = action;
-    }
-  }
-
-  return actionObject;
-}
-var toActionObjects = function (action, actionFunctionMap) {
-  if (!action) {
-    return [];
-  }
-
-  var actions = isArray(action) ? action : [action];
-  return actions.map(function (subAction) {
-    return toActionObject(subAction, actionFunctionMap);
-  });
-};
-function toActivityDefinition(action) {
-  var actionObject = toActionObject(action);
-  return __assign(__assign({
-    id: isString(action) ? action : actionObject.id
-  }, actionObject), {
-    type: actionObject.type
-  });
-}
-/**
- * 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.
- *
- * @param eventType The event to raise.
- */
-
-function raise(event) {
-  if (!isString(event)) {
-    return send(event, {
-      to: SpecialTargets.Internal
-    });
-  }
-
-  return {
-    type: raise$1,
-    event: event
-  };
-}
-function resolveRaise(action) {
-  return {
-    type: raise$1,
-    _event: toSCXMLEvent(action.event)
-  };
-}
-/**
- * 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.
- *
- * @param event The event to send.
- * @param options Options to pass into the send event:
- *  - `id` - The unique send event identifier (used with `cancel()`).
- *  - `delay` - The number of milliseconds to delay the sending of the event.
- *  - `to` - The target of this event (by default, the machine the event was sent from).
- */
-
-function send(event, options) {
-  return {
-    to: options ? options.to : undefined,
-    type: send$1,
-    event: isFunction(event) ? event : toEventObject(event),
-    delay: options ? options.delay : undefined,
-    id: options && options.id !== undefined ? options.id : isFunction(event) ? event.name : getEventType(event)
-  };
-}
-function resolveSend(action, ctx, _event, delaysMap) {
-  var meta = {
-    _event: _event
-  }; // TODO: helper function for resolving Expr
-
-  var resolvedEvent = toSCXMLEvent(isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
-  var resolvedDelay;
-
-  if (isString(action.delay)) {
-    var configDelay = delaysMap && delaysMap[action.delay];
-    resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
-  } else {
-    resolvedDelay = isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
-  }
-
-  var resolvedTarget = isFunction(action.to) ? action.to(ctx, _event.data, meta) : action.to;
-  return __assign(__assign({}, action), {
-    to: resolvedTarget,
-    _event: resolvedEvent,
-    event: resolvedEvent.data,
-    delay: resolvedDelay
-  });
-}
-/**
- * Sends an event to this machine's parent.
- *
- * @param event The event to send to the parent machine.
- * @param options Options to pass into the send event.
- */
-
-function sendParent(event, options) {
-  return send(event, __assign(__assign({}, options), {
-    to: SpecialTargets.Parent
-  }));
-}
-/**
- * Sends an event to an actor.
- *
- * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event to send
- * @param options Send action options
- * @returns An XState send action object
- */
-
-function sendTo(actor, event, options) {
-  return send(event, __assign(__assign({}, options), {
-    to: actor
-  }));
-}
-/**
- * Sends an update event to this machine's parent.
- */
-
-function sendUpdate() {
-  return sendParent(update);
-}
-/**
- * Sends an event back to the sender of the original event.
- *
- * @param event The event to send back to the sender
- * @param options Options to pass into the send event
- */
-
-function respond(event, options) {
-  return send(event, __assign(__assign({}, options), {
-    to: function (_, __, _a) {
-      var _event = _a._event;
-      return _event.origin; // TODO: handle when _event.origin is undefined
-    }
-  }));
-}
-
-var defaultLogExpr = function (context, event) {
-  return {
-    context: context,
-    event: event
-  };
-};
-/**
- *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
- * @param label The label to give to the logged expression.
- */
-
-
-function log(expr, label) {
-  if (expr === void 0) {
-    expr = defaultLogExpr;
-  }
-
-  return {
-    type: log$1,
-    label: label,
-    expr: expr
-  };
-}
-var resolveLog = function (action, ctx, _event) {
-  return __assign(__assign({}, action), {
-    value: isString(action.expr) ? action.expr : action.expr(ctx, _event.data, {
-      _event: _event
-    })
-  });
-};
-/**
- * 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
- * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
- *
- * @param sendId The `id` of the `send(...)` action to cancel.
- */
-
-var cancel = function (sendId) {
-  return {
-    type: cancel$1,
-    sendId: sendId
-  };
-};
-/**
- * Starts an activity.
- *
- * @param activity The activity to start.
- */
-
-function start(activity) {
-  var activityDef = toActivityDefinition(activity);
-  return {
-    type: ActionTypes.Start,
-    activity: activityDef,
-    exec: undefined
-  };
-}
-/**
- * Stops an activity.
- *
- * @param actorRef The activity to stop.
- */
-
-function stop(actorRef) {
-  var activity = isFunction(actorRef) ? actorRef : toActivityDefinition(actorRef);
-  return {
-    type: ActionTypes.Stop,
-    activity: activity,
-    exec: undefined
-  };
-}
-function resolveStop(action, context, _event) {
-  var actorRefOrString = isFunction(action.activity) ? action.activity(context, _event.data) : action.activity;
-  var resolvedActorRef = typeof actorRefOrString === 'string' ? {
-    id: actorRefOrString
-  } : actorRefOrString;
-  var actionObject = {
-    type: ActionTypes.Stop,
-    activity: resolvedActorRef
-  };
-  return actionObject;
-}
-/**
- * Updates the current context of the machine.
- *
- * @param assignment An object that represents the partial context to update.
- */
-
-var assign = function (assignment) {
-  return {
-    type: assign$1,
-    assignment: assignment
-  };
-};
-function isActionObject(action) {
-  return typeof action === 'object' && 'type' in action;
-}
-/**
- * Returns an event type that represents an implicit event that
- * is sent after the specified `delay`.
- *
- * @param delayRef The delay in milliseconds
- * @param id The state node ID where this event is handled
- */
-
-function after(delayRef, id) {
-  var idSuffix = id ? "#".concat(id) : '';
-  return "".concat(ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
-}
-/**
- * Returns an event that represents that a final state node
- * has been reached in the parent state node.
- *
- * @param id The final state node's parent state node `id`
- * @param data The data to pass into the event
- */
-
-function done(id, data) {
-  var type = "".concat(ActionTypes.DoneState, ".").concat(id);
-  var eventObject = {
-    type: type,
-    data: data
-  };
-
-  eventObject.toString = function () {
-    return type;
-  };
-
-  return eventObject;
-}
-/**
- * Returns an event that represents that an invoked service has terminated.
- *
- * An invoked service is terminated when it has reached a top-level final state node,
- * but not when it is canceled.
- *
- * @param id The final state node ID
- * @param data The data to pass into the event
- */
-
-function doneInvoke(id, data) {
-  var type = "".concat(ActionTypes.DoneInvoke, ".").concat(id);
-  var eventObject = {
-    type: type,
-    data: data
-  };
-
-  eventObject.toString = function () {
-    return type;
-  };
-
-  return eventObject;
-}
-function error(id, data) {
-  var type = "".concat(ActionTypes.ErrorPlatform, ".").concat(id);
-  var eventObject = {
-    type: type,
-    data: data
-  };
-
-  eventObject.toString = function () {
-    return type;
-  };
-
-  return eventObject;
-}
-function pure(getActions) {
-  return {
-    type: ActionTypes.Pure,
-    get: getActions
-  };
-}
-/**
- * Forwards (sends) an event to a specified service.
- *
- * @param target The target service to forward the event to.
- * @param options Options to pass into the send action creator.
- */
-
-function forwardTo(target, options) {
-  return send(function (_, event) {
-    return event;
-  }, __assign(__assign({}, options), {
-    to: target
-  }));
-}
-/**
- * Escalates an error by sending it as an event to this machine's parent.
- *
- * @param errorData The error data to send, or the expression function that
- * takes in the `context`, `event`, and `meta`, and returns the error data to send.
- * @param options Options to pass into the send action creator.
- */
-
-function escalate(errorData, options) {
-  return sendParent(function (context, event, meta) {
-    return {
-      type: error$1,
-      data: isFunction(errorData) ? errorData(context, event, meta) : errorData
-    };
-  }, __assign(__assign({}, options), {
-    to: SpecialTargets.Parent
-  }));
-}
-function choose(conds) {
-  return {
-    type: ActionTypes.Choose,
-    conds: conds
-  };
-}
-function resolveActions(machine, currentState, currentContext, _event, actions, preserveActionOrder) {
-  if (preserveActionOrder === void 0) {
-    preserveActionOrder = false;
-  }
-
-  var _a = __read(preserveActionOrder ? [[], actions] : partition(actions, function (action) {
-    return action.type === assign$1;
-  }), 2),
-      assignActions = _a[0],
-      otherActions = _a[1];
-
-  var updatedContext = assignActions.length ? updateContext(currentContext, _event, assignActions, currentState) : currentContext;
-  var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
-  var resolvedActions = flatten(otherActions.map(function (actionObject) {
-    var _a;
-
-    switch (actionObject.type) {
-      case raise$1:
-        return resolveRaise(actionObject);
-
-      case send$1:
-        var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
-
-        if (!IS_PRODUCTION) {
-          // warn after resolving as we can create better contextual message here
-          warn(!isString(actionObject.delay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
-          "No delay reference for delay expression '".concat(actionObject.delay, "' was found on machine '").concat(machine.id, "'"));
-        }
-
-        return sendAction;
-
-      case log$1:
-        return resolveLog(actionObject, updatedContext, _event);
-
-      case choose$1:
-        {
-          var chooseAction = actionObject;
-          var matchedActions = (_a = chooseAction.conds.find(function (condition) {
-            var guard = toGuard(condition.cond, machine.options.guards);
-            return !guard || evaluateGuard(machine, guard, updatedContext, _event, currentState);
-          })) === null || _a === void 0 ? void 0 : _a.actions;
-
-          if (!matchedActions) {
-            return [];
-          }
-
-          var _b = __read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
-              resolvedActionsFromChoose = _b[0],
-              resolvedContextFromChoose = _b[1];
-
-          updatedContext = resolvedContextFromChoose;
-          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
-          return resolvedActionsFromChoose;
-        }
-
-      case pure$1:
-        {
-          var matchedActions = actionObject.get(updatedContext, _event.data);
-
-          if (!matchedActions) {
-            return [];
-          }
-
-          var _c = __read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
-              resolvedActionsFromPure = _c[0],
-              resolvedContext = _c[1];
-
-          updatedContext = resolvedContext;
-          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
-          return resolvedActionsFromPure;
-        }
-
-      case stop$1:
-        {
-          return resolveStop(actionObject, updatedContext, _event);
-        }
-
-      case assign$1:
-        {
-          updatedContext = updateContext(updatedContext, _event, [actionObject], currentState);
-          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
-          break;
-        }
-
-      default:
-        var resolvedActionObject = toActionObject(actionObject, machine.options.actions);
-        var exec_1 = resolvedActionObject.exec;
-
-        if (exec_1 && preservedContexts) {
-          var contextIndex_1 = preservedContexts.length - 1;
-          resolvedActionObject = __assign(__assign({}, resolvedActionObject), {
-            exec: function (_ctx) {
-              var args = [];
-
-              for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-              }
-
-              exec_1.apply(void 0, __spreadArray([preservedContexts[contextIndex_1]], __read(args), false));
-            }
-          });
-        }
-
-        return resolvedActionObject;
-    }
-  }).filter(function (a) {
-    return !!a;
-  }));
-  return [resolvedActions, updatedContext];
-}
-
-export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, isActionObject, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, resolveStop, respond, send, sendParent, sendTo, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };

package/es/behaviors.d.ts

@@ -1,37 +0,0 @@
-import { ActorContext, ActorRef, Behavior, EventObject } from './types';
-/**
- * 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
- */
-export declare function fromReducer<TState, TEvent extends EventObject>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState>) => TState, initialState: TState): Behavior<TEvent, TState>;
-declare type PromiseEvents<T> = {
-    type: 'fulfill';
-    data: T;
-} | {
-    type: 'reject';
-    error: unknown;
-};
-declare type PromiseState<T> = {
-    status: 'pending';
-    data: undefined;
-    error: undefined;
-} | {
-    status: 'fulfilled';
-    data: T;
-    error: undefined;
-} | {
-    status: 'rejected';
-    data: undefined;
-    error: any;
-};
-export declare function fromPromise<T>(promiseFn: () => Promise<T>): Behavior<PromiseEvents<T>, PromiseState<T>>;
-interface SpawnBehaviorOptions {
-    id?: string;
-    parent?: ActorRef<any>;
-}
-export declare function spawnBehavior<TEvent extends EventObject, TEmitted>(behavior: Behavior<TEvent, TEmitted>, options?: SpawnBehaviorOptions): ActorRef<TEvent, TEmitted>;
-export {};
-//# sourceMappingURL=behaviors.d.ts.map

package/es/behaviors.js

@@ -1,131 +0,0 @@
-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 = {};
-  }
-
-  var state = behavior.initialState;
-  var observers = new Set();
-  var mailbox = [];
-  var flushing = false;
-
-  var flush = function () {
-    if (flushing) {
-      return;
-    }
-
-    flushing = true;
-
-    while (mailbox.length > 0) {
-      var event_1 = mailbox.shift();
-      state = behavior.transition(state, event_1, actorCtx);
-      observers.forEach(function (observer) {
-        return observer.next(state);
-      });
-    }
-
-    flushing = false;
-  };
-
-  var actor = toActorRef({
-    id: options.id,
-    send: function (event) {
-      mailbox.push(event);
-      flush();
-    },
-    getSnapshot: function () {
-      return state;
-    },
-    subscribe: function (next, handleError, complete) {
-      var observer = toObserver(next, handleError, complete);
-      observers.add(observer);
-      observer.next(state);
-      return {
-        unsubscribe: function () {
-          observers.delete(observer);
-        }
-      };
-    }
-  });
-  var actorCtx = {
-    parent: options.parent,
-    self: actor,
-    id: options.id || 'anonymous',
-    observers: observers
-  };
-  state = behavior.start ? behavior.start(actorCtx) : state;
-  return actor;
-}
-
-export { fromPromise, fromReducer, spawnBehavior };

package/es/constants.d.ts

@@ -1,6 +0,0 @@
-import { ActivityMap, DefaultGuardType } from './types';
-export declare const STATE_DELIMITER = ".";
-export declare const EMPTY_ACTIVITY_MAP: ActivityMap;
-export declare const DEFAULT_GUARD_TYPE: DefaultGuardType;
-export declare const TARGETLESS_KEY = "";
-//# sourceMappingURL=constants.d.ts.map

package/es/constants.js

@@ -1,6 +0,0 @@
-var STATE_DELIMITER = '.';
-var EMPTY_ACTIVITY_MAP = {};
-var DEFAULT_GUARD_TYPE = 'xstate.guard';
-var TARGETLESS_KEY = '';
-
-export { DEFAULT_GUARD_TYPE, EMPTY_ACTIVITY_MAP, STATE_DELIMITER, TARGETLESS_KEY };