xstate 5.0.0-beta.40 → 5.0.0-beta.42

package/dist/{raise-8325e2df.development.cjs.js → raise-8f482ce9.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-bae5c279.development.cjs.js');
+var interpreter = require('./interpreter-23e4041c.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -63,7 +63,7 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
     const configuredInput = input || referenced.input;
     actorRef = interpreter.createActor(referenced.src, {
       id: resolvedId,
-      src: typeof src === 'string' ? src : undefined,
+      src,
       parent: actorScope?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
@@ -89,7 +89,7 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   if (!actorRef) {
     console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
   }
-  return [cloneState(state, {
+  return [cloneMachineSnapshot(state, {
     children: {
       ...state.children,
       [resolvedId]: actorRef
@@ -107,7 +107,7 @@ function executeSpawn(actorScope, {
     return;
   }
   actorScope.defer(() => {
-    if (actorRef.status === interpreter.ActorStatus.Stopped) {
+    if (actorRef._processingStatus === interpreter.ProcessingStatus.Stopped) {
       return;
     }
     try {
@@ -152,7 +152,7 @@ function resolveStop(_, state, args, actionParams, {
     };
     delete children[resolvedActorRef.id];
   }
-  return [cloneState(state, {
+  return [cloneMachineSnapshot(state, {
     children
   }), resolvedActorRef];
 }
@@ -168,7 +168,7 @@ function executeStop(actorScope, actorRef) {
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
-  if (actorRef.status !== interpreter.ActorStatus.Running) {
+  if (actorRef._processingStatus !== interpreter.ProcessingStatus.Running) {
     actorScope.stopChild(actorRef);
     return;
   }
@@ -685,10 +685,9 @@ function getStateNodeByPath(stateNode, statePath) {
 /**
  * Returns the state nodes represented by the current state value.
  *
- * @param state The state value or State instance
+ * @param stateValue The state value or State instance
  */
-function getStateNodes(stateNode, state) {
-  const stateValue = state instanceof State ? state.value : interpreter.toStateValue(state);
+function getStateNodes(stateNode, stateValue) {
   if (typeof stateValue === 'string') {
     return [stateNode, stateNode.states[stateValue]];
   }
@@ -909,7 +908,7 @@ function microstep(transitions, currentState, actorScope, event, isInitial, inte
     if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
       return nextState;
     }
-    return cloneState(nextState, {
+    return cloneMachineSnapshot(nextState, {
       configuration: nextConfiguration,
       historyValue
     });
@@ -973,9 +972,9 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutCo
       if (ancestorMarker) {
         continue;
       }
-      nextState = cloneState(nextState, {
+      nextState = cloneMachineSnapshot(nextState, {
         status: 'done',
-        output: getMachineOutput(nextState, event, actorScope, currentState.configuration[0].machine.root, rootCompletionNode)
+        output: getMachineOutput(nextState, event, actorScope, nextState.machine.root, rootCompletionNode)
       });
     }
   }
@@ -1129,7 +1128,7 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       event
     }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
-      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
+      if (actorScope?.self._processingStatus === interpreter.ProcessingStatus.Running) {
         resolvedAction(actionArgs, actionParams);
       } else {
         actorScope?.defer(() => {
@@ -1147,7 +1146,7 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
+      if (actorScope?.self._processingStatus === interpreter.ProcessingStatus.Running) {
         builtinAction.execute(actorScope, params);
       } else {
         actorScope?.defer(builtinAction.execute.bind(null, actorScope, params));
@@ -1179,7 +1178,7 @@ function macrostep(state, event, actorScope, internalQueue = []) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = cloneState(stopChildren(nextState, event, actorScope), {
+    nextState = cloneMachineSnapshot(stopChildren(nextState, event, actorScope), {
       status: 'stopped'
     });
     states.push(nextState);
@@ -1257,194 +1256,96 @@ function resolveStateValue(rootNode, stateValue) {
   const configuration = getConfiguration(getStateNodes(rootNode, stateValue));
   return getStateValue(rootNode, [...configuration]);
 }
-function getInitialConfiguration(rootNode) {
-  const configuration = [];
-  const initialTransition = rootNode.initial;
-  const statesToEnter = new Set();
-  const statesForDefaultEntry = new Set([rootNode]);
-  computeEntrySet([initialTransition], {}, statesForDefaultEntry, statesToEnter);
-  for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
-    configuration.push(stateNodeToEnter);
-  }
-  return configuration;
-}
-
-class State {
-  /**
-   * Indicates whether the state is a final state.
-   */
-
-  /**
-   * The output data of the top-level finite state.
-   */
-
-  /**
-   * The enabled state nodes representative of the state value.
-   */
-
-  /**
-   * An object mapping actor names to spawned/invoked actors.
-   */
-
-  /**
-   * Creates a new State instance for the given `stateValue` and `context`.
-   * @param stateValue
-   * @param context
-   */
-  static from(stateValue, context = {}, machine) {
-    if (stateValue instanceof State) {
-      if (stateValue.context !== context) {
-        return new State({
-          value: stateValue.value,
-          context,
-          meta: {},
-          configuration: [],
-          // TODO: fix,
-          children: {},
-          status: 'active'
-        }, machine);
-      }
-      return stateValue;
-    }
-    const configuration = getConfiguration(getStateNodes(machine.root, stateValue));
-    return new State({
-      value: stateValue,
-      context,
-      meta: undefined,
-      configuration: Array.from(configuration),
-      children: {},
-      status: 'active'
-    }, machine);
-  }
-
-  /**
-   * Creates a new `State` instance that represents the current state of a running machine.
-   *
-   * @param config
-   */
-  constructor(config, machine) {
-    this.machine = machine;
-    this.tags = void 0;
-    this.value = void 0;
-    this.status = void 0;
-    this.error = void 0;
-    this.context = void 0;
-    this.historyValue = {};
-    this.configuration = void 0;
-    this.children = void 0;
-    this.context = config.context;
-    this.historyValue = config.historyValue || {};
-    this.matches = this.matches.bind(this);
-    this.toStrings = this.toStrings.bind(this);
-    this.configuration = config.configuration ?? Array.from(getConfiguration(getStateNodes(machine.root, config.value)));
-    this.children = config.children;
-    this.value = getStateValue(machine.root, this.configuration);
-    this.tags = new Set(interpreter.flatten(this.configuration.map(sn => sn.tags)));
-    this.status = config.status;
-    this.output = config.output;
-    this.error = config.error;
-  }
-
-  /**
-   * Returns an array of all the string leaf state node paths.
-   * @param stateValue
-   * @param delimiter The character(s) that separate each subpath in the string state node path.
-   */
-  toStrings(stateValue = this.value) {
-    if (typeof stateValue === 'string') {
-      return [stateValue];
-    }
-    const valueKeys = Object.keys(stateValue);
-    return valueKeys.concat(...valueKeys.map(key => this.toStrings(stateValue[key]).map(s => key + interpreter.STATE_DELIMITER + s)));
-  }
-  toJSON() {
-    const {
-      configuration,
-      tags,
-      machine,
-      ...jsonValues
-    } = this;
-    return {
-      ...jsonValues,
-      tags: Array.from(tags),
-      meta: this.meta
-    };
-  }
-
-  /**
-   * Whether the current state value is a subset of the given parent state value.
-   * @param parentStateValue
-   */
-  matches(parentStateValue) {
-    return interpreter.matchesState(parentStateValue, this.value);
-  }
-
-  /**
-   * Whether the current state configuration has a state node with the specified `tag`.
-   * @param tag
-   */
-  hasTag(tag) {
-    return this.tags.has(tag);
-  }
 
-  /**
-   * Determines whether sending the `event` will cause a non-forbidden transition
-   * to be selected, even if the transitions have no actions nor
-   * change the state value.
-   *
-   * @param event The event to test
-   * @returns Whether the event will cause a transition
-   */
-  can(event) {
-    if (!this.machine) {
-      console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
-    }
-    const transitionData = this.machine.getTransitionData(this, event);
-    return !!transitionData?.length &&
-    // Check that at least one transition is not forbidden
-    transitionData.some(t => t.target !== undefined || t.actions.length);
-  }
-
-  /**
-   * The next events that will cause a transition from the current state.
-   */
-  get nextEvents() {
-    return memo(this, 'nextEvents', () => {
-      return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-    });
-  }
-  get meta() {
-    return this.configuration.reduce((acc, stateNode) => {
-      if (stateNode.meta !== undefined) {
-        acc[stateNode.id] = stateNode.meta;
+function createMachineSnapshot(config, machine) {
+  return {
+    status: config.status,
+    output: config.output,
+    error: config.error,
+    machine,
+    context: config.context,
+    configuration: config.configuration,
+    value: getStateValue(machine.root, config.configuration),
+    tags: new Set(interpreter.flatten(config.configuration.map(sn => sn.tags))),
+    children: config.children,
+    historyValue: config.historyValue || {},
+    matches(parentStateValue) {
+      return interpreter.matchesState(parentStateValue, this.value);
+    },
+    hasTag(tag) {
+      return this.tags.has(tag);
+    },
+    can(event) {
+      if (!this.machine) {
+        console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
       }
-      return acc;
-    }, {});
-  }
+      const transitionData = this.machine.getTransitionData(this, event);
+      return !!transitionData?.length &&
+      // Check that at least one transition is not forbidden
+      transitionData.some(t => t.target !== undefined || t.actions.length);
+    },
+    get nextEvents() {
+      return memo(this, 'nextEvents', () => {
+        return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+      });
+    },
+    get meta() {
+      return this.configuration.reduce((acc, stateNode) => {
+        if (stateNode.meta !== undefined) {
+          acc[stateNode.id] = stateNode.meta;
+        }
+        return acc;
+      }, {});
+    },
+    toJSON() {
+      const {
+        configuration,
+        tags,
+        machine,
+        nextEvents,
+        toJSON,
+        can,
+        hasTag,
+        matches,
+        ...jsonValues
+      } = this;
+      return {
+        ...jsonValues,
+        tags: Array.from(tags)
+      };
+    }
+  };
 }
-function cloneState(state, config = {}) {
-  return new State({
+function cloneMachineSnapshot(state, config = {}) {
+  return createMachineSnapshot(
+  // TODO: it's wasteful that this spread triggers getters
+  {
     ...state,
     ...config
   }, state.machine);
 }
-function getPersistedState(state) {
+function getPersistedState(state, options) {
   const {
     configuration,
     tags,
     machine,
     children,
     context,
+    can,
+    hasTag,
+    matches,
+    toJSON,
+    nextEvents,
     ...jsonValues
   } = state;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
-    if (typeof child.src !== 'string') {
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
       throw new Error('An inline child actor cannot be persisted.');
     }
     childrenJson[id] = {
-      state: child.getPersistedState(),
+      state: child.getPersistedState(options),
       src: child.src,
       systemId: child._systemId
     };
@@ -1538,10 +1439,10 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-exports.State = State;
 exports.and = and;
 exports.cancel = cancel;
-exports.cloneState = cloneState;
+exports.cloneMachineSnapshot = cloneMachineSnapshot;
+exports.createMachineSnapshot = createMachineSnapshot;
 exports.evaluateGuard = evaluateGuard;
 exports.formatInitialTransition = formatInitialTransition;
 exports.formatTransition = formatTransition;
@@ -1549,7 +1450,6 @@ exports.formatTransitions = formatTransitions;
 exports.getCandidates = getCandidates;
 exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
-exports.getInitialConfiguration = getInitialConfiguration;
 exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;