xstate 5.0.0-beta.10 → 5.0.0-beta.12

package/dist/xstate.development.esm.js

@@ -0,0 +1,770 @@
+import { m as mapValues, t as toActionObjects, a as toArray, f as formatTransitions, b as toTransitionConfigArray, N as NULL_EVENT, c as formatTransition, d as memo, e as evaluateGuard, g as flatten, h as createInvokeId, i as isString, j as invoke, k as getDelayedTransitions, l as formatInitialTransition, n as getCandidates, o as toInvokeConfig, p as createSpawner, S as STATE_DELIMITER, q as getConfiguration, r as getStateNodes, s as resolveStateValue, u as isInFinalState, v as State, w as isErrorEvent, x as macrostep, y as transitionNode, z as getInitialConfiguration, A as createInitEvent, B as resolveActionsAndContext, C as microstep, D as error, E as isStateId, F as getStateNodeByPath, G as getPersistedState, H as resolveReferencedActor, I as interpret, J as initEvent, K as matchesState } from './actions-c8b9504d.development.esm.js';
+export { a9 as ActionTypes, P as Interpreter, Q as InterpreterStatus, aa as SpecialTargets, v as State, a7 as and, T as assign, U as cancel, V as choose, R as doneInvoke, O as forwardTo, a2 as fromCallback, a3 as fromEventObservable, a1 as fromObservable, a0 as fromPromise, a4 as fromTransition, r as getStateNodes, I as interpret, W as log, K as matchesState, a6 as not, a8 as or, _ as pathToStateValue, X as pure, Y as raise, M as sendParent, L as sendTo, a5 as stateIn, Z as stop, $ as toObserver } from './actions-c8b9504d.development.esm.js';
+import '../dev/dist/xstate-dev.development.esm.js';
+
+const EMPTY_OBJECT = {};
+class StateNode {
+  /**
+   * The relative key of the state node, which represents its location in the overall state value.
+   */
+
+  /**
+   * The unique ID of the state node.
+   */
+
+  /**
+   * The type of this state node:
+   *
+   *  - `'atomic'` - no child state nodes
+   *  - `'compound'` - nested child state nodes (XOR)
+   *  - `'parallel'` - orthogonal nested child state nodes (AND)
+   *  - `'history'` - history state node
+   *  - `'final'` - final state node
+   */
+
+  /**
+   * The string path from the root machine node to this node.
+   */
+
+  /**
+   * The child state nodes.
+   */
+
+  /**
+   * The type of history on this state node. Can be:
+   *
+   *  - `'shallow'` - recalls only top-level historical state value
+   *  - `'deep'` - recalls historical state value at all levels
+   */
+
+  /**
+   * The action(s) to be executed upon entering the state node.
+   */
+
+  /**
+   * The action(s) to be executed upon exiting the state node.
+   */
+
+  /**
+   * The parent state node.
+   */
+
+  /**
+   * The root machine node.
+   */
+
+  /**
+   * The meta data associated with this state node, which will be returned in State instances.
+   */
+
+  /**
+   * The output data sent with the "done.state._id_" event if this is a final state node.
+   */
+
+  /**
+   * The order this state node appears. Corresponds to the implicit document order.
+   */
+
+  constructor(
+  /**
+   * The raw config used to create the machine.
+   */
+  config, options) {
+    this.config = config;
+    this.key = void 0;
+    this.id = void 0;
+    this.type = void 0;
+    this.path = void 0;
+    this.states = void 0;
+    this.history = void 0;
+    this.entry = void 0;
+    this.exit = void 0;
+    this.parent = void 0;
+    this.machine = void 0;
+    this.meta = void 0;
+    this.output = void 0;
+    this.order = -1;
+    this.description = void 0;
+    this.tags = [];
+    this.transitions = void 0;
+    this.always = void 0;
+    this.parent = options._parent;
+    this.key = options._key;
+    this.machine = options._machine;
+    this.path = this.parent ? this.parent.path.concat(this.key) : [];
+    this.id = this.config.id || [this.machine.id, ...this.path].join(this.machine.delimiter);
+    this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
+    this.description = this.config.description;
+    this.order = this.machine.idMap.size;
+    this.machine.idMap.set(this.id, this);
+    this.states = this.config.states ? mapValues(this.config.states, (stateConfig, key) => {
+      const stateNode = new StateNode(stateConfig, {
+        _parent: this,
+        _key: key,
+        _machine: this.machine
+      });
+      return stateNode;
+    }) : EMPTY_OBJECT;
+    if (this.type === 'compound' && !this.config.initial) {
+      throw new Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
+    }
+
+    // History config
+    this.history = this.config.history === true ? 'shallow' : this.config.history || false;
+    this.entry = toActionObjects(this.config.entry);
+    this.exit = toActionObjects(this.config.exit);
+    this.meta = this.config.meta;
+    this.output = this.type === 'final' ? this.config.output : undefined;
+    this.tags = toArray(config.tags);
+  }
+  _initialize() {
+    this.transitions = formatTransitions(this);
+    if (this.config.always) {
+      this.always = toTransitionConfigArray(NULL_EVENT, this.config.always).map(t => formatTransition(this, t));
+    }
+    Object.keys(this.states).forEach(key => {
+      this.states[key]._initialize();
+    });
+  }
+
+  /**
+   * The well-structured state node definition.
+   */
+  get definition() {
+    return {
+      id: this.id,
+      key: this.key,
+      version: this.machine.version,
+      type: this.type,
+      initial: this.initial ? {
+        target: this.initial.target,
+        source: this,
+        actions: this.initial.actions,
+        eventType: null,
+        reenter: false,
+        toJSON: () => ({
+          target: this.initial.target.map(t => `#${t.id}`),
+          source: `#${this.id}`,
+          actions: this.initial.actions,
+          eventType: null
+        })
+      } : undefined,
+      history: this.history,
+      states: mapValues(this.states, state => {
+        return state.definition;
+      }),
+      on: this.on,
+      transitions: this.transitions,
+      entry: this.entry,
+      exit: this.exit,
+      meta: this.meta,
+      order: this.order || -1,
+      output: this.output,
+      invoke: this.invoke,
+      description: this.description,
+      tags: this.tags
+    };
+  }
+  toJSON() {
+    return this.definition;
+  }
+
+  /**
+   * The behaviors invoked as actors by this state node.
+   */
+  get invoke() {
+    return memo(this, 'invoke', () => toArray(this.config.invoke).map((invocable, i) => {
+      const generatedId = createInvokeId(this.id, i);
+      const invokeConfig = toInvokeConfig(invocable, generatedId);
+      const resolvedId = invokeConfig.id || generatedId;
+      const {
+        src,
+        systemId
+      } = invokeConfig;
+      const resolvedSrc = isString(src) ? src : !('type' in src) ? resolvedId : src;
+      if (!this.machine.options.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
+        this.machine.options.actors = {
+          ...this.machine.options.actors,
+          // TODO: this should accept `src` as-is
+          [resolvedId]: src
+        };
+      }
+      return {
+        type: invoke,
+        ...invokeConfig,
+        src: resolvedSrc,
+        id: resolvedId,
+        systemId: systemId,
+        toJSON() {
+          const {
+            onDone,
+            onError,
+            ...invokeDefValues
+          } = invokeConfig;
+          return {
+            ...invokeDefValues,
+            type: invoke,
+            src: resolvedSrc,
+            id: resolvedId
+          };
+        }
+      };
+    }));
+  }
+
+  /**
+   * The mapping of events to transitions.
+   */
+  get on() {
+    return memo(this, 'on', () => {
+      const transitions = this.transitions;
+      return transitions.reduce((map, transition) => {
+        map[transition.eventType] = map[transition.eventType] || [];
+        map[transition.eventType].push(transition);
+        return map;
+      }, {});
+    });
+  }
+  get after() {
+    return memo(this, 'delayedTransitions', () => getDelayedTransitions(this));
+  }
+  get initial() {
+    return memo(this, 'initial', () => formatInitialTransition(this, this.config.initial || []));
+  }
+  next(state, event) {
+    const eventType = event.type;
+    const actions = [];
+    let selectedTransition;
+    const candidates = memo(this, `candidates-${eventType}`, () => getCandidates(this, eventType));
+    for (const candidate of candidates) {
+      const {
+        guard
+      } = candidate;
+      const resolvedContext = state.context;
+      let guardPassed = false;
+      try {
+        guardPassed = !guard || evaluateGuard(guard, resolvedContext, event, state);
+      } catch (err) {
+        throw new Error(`Unable to evaluate guard '${guard.type}' in transition for event '${eventType}' in state node '${this.id}':\n${err.message}`);
+      }
+      if (guardPassed) {
+        actions.push(...candidate.actions);
+        selectedTransition = candidate;
+        break;
+      }
+    }
+    return selectedTransition ? [selectedTransition] : undefined;
+  }
+
+  /**
+   * The target state value of the history state node, if it exists. This represents the
+   * default state value to transition to if no history value exists yet.
+   */
+  get target() {
+    if (this.type === 'history') {
+      const historyConfig = this.config;
+      return historyConfig.target;
+    }
+    return undefined;
+  }
+
+  /**
+   * All the state node IDs of this state node and its descendant state nodes.
+   */
+  get stateIds() {
+    const childStateIds = flatten(Object.keys(this.states).map(stateKey => {
+      return this.states[stateKey].stateIds;
+    }));
+    return [this.id].concat(childStateIds);
+  }
+
+  /**
+   * All the event types accepted by this state node and its descendants.
+   */
+  get events() {
+    return memo(this, 'events', () => {
+      const {
+        states
+      } = this;
+      const events = new Set(this.ownEvents);
+      if (states) {
+        for (const stateId of Object.keys(states)) {
+          const state = states[stateId];
+          if (state.states) {
+            for (const event of state.events) {
+              events.add(`${event}`);
+            }
+          }
+        }
+      }
+      return Array.from(events);
+    });
+  }
+
+  /**
+   * All the events that have transitions directly from this state node.
+   *
+   * Excludes any inert events.
+   */
+  get ownEvents() {
+    const events = new Set(this.transitions.filter(transition => {
+      return !(!transition.target && !transition.actions.length && !transition.reenter);
+    }).map(transition => transition.eventType));
+    return Array.from(events);
+  }
+}
+
+const STATE_IDENTIFIER = '#';
+function createDefaultOptions() {
+  return {
+    actions: {},
+    actors: {},
+    delays: {},
+    guards: {},
+    context: {}
+  };
+}
+class StateMachine {
+  // TODO: this getter should be removed
+  getContext(input) {
+    return this.getContextAndActions(undefined, input)[0];
+  }
+  getContextAndActions(actorCtx, input) {
+    const actions = [];
+    const {
+      context
+    } = this.config;
+    const resolvedContext = typeof context === 'function' ? context({
+      spawn: createSpawner(actorCtx?.self, this, undefined,
+      // TODO: this requires `| undefined` for all referenced dynamic inputs that are spawnable in the context factory,
+      createInitEvent(input), actions),
+      input
+    }) : context;
+    return [resolvedContext || {}, actions];
+  }
+  /**
+   * The machine's own version.
+   */
+
+  constructor(
+  /**
+   * The raw config used to create the machine.
+   */
+  config, options) {
+    this.config = config;
+    this.version = void 0;
+    this.delimiter = void 0;
+    this.options = void 0;
+    this.types = void 0;
+    this.__xstatenode = true;
+    this.idMap = new Map();
+    this.root = void 0;
+    this.id = void 0;
+    this.states = void 0;
+    this.events = void 0;
+    this.__TContext = void 0;
+    this.__TEvent = void 0;
+    this.__TAction = void 0;
+    this.__TActorMap = void 0;
+    this.__TResolvedTypesMeta = void 0;
+    this.id = config.id || '(machine)';
+    this.options = Object.assign(createDefaultOptions(), options);
+    this.delimiter = this.config.delimiter || STATE_DELIMITER;
+    this.version = this.config.version;
+    this.types = this.config.types ?? {};
+    this.transition = this.transition.bind(this);
+    this.root = new StateNode(config, {
+      _key: this.id,
+      _machine: this
+    });
+    this.root._initialize();
+    this.states = this.root.states; // TODO: remove!
+    this.events = this.root.events;
+  }
+
+  /**
+   * Clones this state machine with the provided implementations
+   * and merges the `context` (if provided).
+   *
+   * @param implementations Options (`actions`, `guards`, `actors`, `delays`, `context`)
+   *  to recursively merge with the existing options.
+   *
+   * @returns A new `StateMachine` instance with the provided implementations.
+   */
+  provide(implementations) {
+    const {
+      actions,
+      guards,
+      actors,
+      delays
+    } = this.options;
+    return new StateMachine(this.config, {
+      actions: {
+        ...actions,
+        ...implementations.actions
+      },
+      guards: {
+        ...guards,
+        ...implementations.guards
+      },
+      actors: {
+        ...actors,
+        ...implementations.actors
+      },
+      delays: {
+        ...delays,
+        ...implementations.delays
+      }
+    });
+  }
+
+  /**
+   * Resolves the given `state` to a new `State` instance relative to this machine.
+   *
+   * This ensures that `.nextEvents` represent the correct values.
+   *
+   * @param state The state to resolve
+   */
+  resolveState(state) {
+    const configurationSet = getConfiguration(getStateNodes(this.root, state.value));
+    const configuration = Array.from(configurationSet);
+    return this.createState({
+      ...state,
+      value: resolveStateValue(this.root, state.value),
+      configuration,
+      done: isInFinalState(configuration)
+    });
+  }
+  resolveStateValue(stateValue) {
+    const resolvedStateValue = resolveStateValue(this.root, stateValue);
+    const resolvedContext = this.getContext();
+    return this.resolveState(State.from(resolvedStateValue, resolvedContext, this));
+  }
+
+  /**
+   * Determines the next state given the current `state` and received `event`.
+   * Calculates a full macrostep from all microsteps.
+   *
+   * @param state The current State instance or state value
+   * @param event The received event
+   */
+  transition(state = this.initialState, event, actorCtx) {
+    const currentState = state instanceof State ? state : this.resolveStateValue(state);
+    // TODO: handle error events in a better way
+    if (isErrorEvent(event) && !currentState.nextEvents.some(nextEvent => nextEvent === event.type)) {
+      throw event.data;
+    }
+    const {
+      state: nextState
+    } = macrostep(currentState, event, actorCtx);
+    return nextState;
+  }
+
+  /**
+   * Determines the next state given the current `state` and `event`.
+   * Calculates a microstep.
+   *
+   * @param state The current state
+   * @param event The received event
+   */
+  microstep(state = this.initialState, event, actorCtx) {
+    return macrostep(state, event, actorCtx).microstates;
+  }
+  getTransitionData(state, event) {
+    return transitionNode(this.root, state.value, state, event) || [];
+  }
+
+  /**
+   * The initial state _before_ evaluating any microsteps.
+   * This "pre-initial" state is provided to initial actions executed in the initial state.
+   */
+  getPreInitialState(actorCtx, input) {
+    const [context, actions] = this.getContextAndActions(actorCtx, input);
+    const config = getInitialConfiguration(this.root);
+    const preInitial = this.resolveState(this.createState({
+      value: {},
+      // TODO: this is computed in state constructor
+      context,
+      event: createInitEvent({}),
+      actions: [],
+      meta: undefined,
+      configuration: config,
+      transitions: [],
+      children: {}
+    }));
+    preInitial._initial = true;
+    preInitial.actions.unshift(...actions);
+    if (actorCtx) {
+      const {
+        nextState
+      } = resolveActionsAndContext(actions, initEvent, preInitial, actorCtx);
+      preInitial.children = nextState.children;
+      preInitial.actions = nextState.actions;
+    }
+    return preInitial;
+  }
+
+  /**
+   * The initial State instance, which includes all actions to be executed from
+   * entering the initial state.
+   */
+  get initialState() {
+    return this.getInitialState();
+  }
+
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
+   */
+  getInitialState(actorCtx, input) {
+    const initEvent = createInitEvent(input); // TODO: fix;
+
+    const preInitialState = this.getPreInitialState(actorCtx, input);
+    const nextState = microstep([], preInitialState, actorCtx, initEvent);
+    nextState.actions.unshift(...preInitialState.actions);
+    const {
+      state: macroState
+    } = macrostep(nextState, initEvent, actorCtx);
+    return macroState;
+  }
+  start(state, actorCtx) {
+    state.actions.forEach(action => {
+      action.execute?.(actorCtx);
+    });
+    Object.values(state.children).forEach(child => {
+      if (child.status === 0) {
+        try {
+          child.start?.();
+        } catch (err) {
+          // TODO: unify error handling when child starts
+          actorCtx.self.send(error(child.id, err));
+        }
+      }
+    });
+  }
+  getStateNodeById(stateId) {
+    const fullPath = stateId.split(this.delimiter);
+    const relativePath = fullPath.slice(1);
+    const resolvedStateId = isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
+    const stateNode = this.idMap.get(resolvedStateId);
+    if (!stateNode) {
+      throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
+    }
+    return getStateNodeByPath(stateNode, relativePath);
+  }
+  get definition() {
+    return {
+      context: this.getContext(),
+      ...this.root.definition
+    };
+  }
+  toJSON() {
+    return this.definition;
+  }
+  getPersistedState(state) {
+    return getPersistedState(state);
+  }
+  createState(stateConfig) {
+    const state = stateConfig instanceof State ? stateConfig : new State(stateConfig, this);
+    const {
+      nextState: resolvedState
+    } = resolveActionsAndContext(state.actions, state.event, state, undefined);
+    return resolvedState;
+  }
+  getStatus(state) {
+    return state.done ? {
+      status: 'done',
+      data: state.output
+    } : {
+      status: 'active'
+    };
+  }
+  restoreState(state, _actorCtx) {
+    const children = {};
+    Object.keys(state.children).forEach(actorId => {
+      const actorData = state.children[actorId];
+      const childState = actorData.state;
+      const src = actorData.src;
+      const behavior = src ? resolveReferencedActor(this.options.actors[src])?.src : undefined;
+      if (!behavior) {
+        return;
+      }
+      const actorState = behavior.restoreState?.(childState, _actorCtx);
+      const actorRef = interpret(behavior, {
+        id: actorId,
+        state: actorState
+      });
+      children[actorId] = actorRef;
+    });
+    const restoredState = this.createState(new State({
+      ...state,
+      children
+    }, this));
+
+    // TODO: DRY this up
+    restoredState.configuration.forEach(stateNode => {
+      if (stateNode.invoke) {
+        stateNode.invoke.forEach(invokeConfig => {
+          const {
+            id,
+            src
+          } = invokeConfig;
+          if (children[id]) {
+            return;
+          }
+          const referenced = resolveReferencedActor(this.options.actors[src]);
+          if (referenced) {
+            const actorRef = interpret(referenced.src, {
+              id,
+              parent: _actorCtx?.self,
+              input: 'input' in invokeConfig ? invokeConfig.input : referenced.input
+            });
+            children[id] = actorRef;
+          }
+        });
+      }
+    });
+    restoredState.actions = [];
+    return restoredState;
+  }
+
+  /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+}
+
+function createMachine(config, implementations) {
+  return new StateMachine(config, implementations);
+}
+
+function mapState(stateMap, stateId) {
+  let foundStateId;
+  for (const mappedStateId of Object.keys(stateMap)) {
+    if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
+    }
+  }
+  return stateMap[foundStateId];
+}
+
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(([id, timeout]) => {
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    });
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
+
+const defaultWaitForOptions = {
+  timeout: 10_000 // 10 seconds
+};
+
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy
+ * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
+ *
+ * @example
+ * ```js
+ * const state = await waitFor(someService, state => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value
+ * that matches the condition
+ */
+function waitFor(actorRef, predicate, options) {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    if (resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
+      sub.unsubscribe();
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+    }, resolvedOptions.timeout);
+    const dispose = () => {
+      clearTimeout(handle);
+      done = true;
+      sub?.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+    let sub; // avoid TDZ when disposing synchronously
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: err => {
+        dispose();
+        rej(err);
+      },
+      complete: () => {
+        dispose();
+        rej(new Error(`Actor terminated without satisfying predicate`));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
+export { SimulatedClock, StateMachine, StateNode, createMachine, mapState, waitFor };