xstate 5.0.0-beta.41 → 5.0.0-beta.43

package/dist/{raise-5ab465ed.development.cjs.js → raise-23dea0d7.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-70ed981b.development.cjs.js');
+var interpreter = require('./interpreter-4e8e2a0d.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -52,25 +52,20 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   input,
   syncSnapshot
 }) {
-  const referenced = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : {
-    src,
-    input: undefined
-  };
+  const logic = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
-  if (referenced) {
-    // TODO: inline `input: undefined` should win over the referenced one
-    const configuredInput = input || referenced.input;
-    actorRef = interpreter.createActor(referenced.src, {
+  if (logic) {
+    actorRef = interpreter.createActor(logic, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
       systemId,
-      input: typeof configuredInput === 'function' ? configuredInput({
+      input: typeof input === 'function' ? input({
         context: state.context,
         event: actionArgs.event,
         self: actorScope?.self
-      }) : configuredInput
+      }) : input
     });
     if (syncSnapshot) {
       actorRef.subscribe({
@@ -89,7 +84,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
@@ -152,7 +147,7 @@ function resolveStop(_, state, args, actionParams, {
     };
     delete children[resolvedActorRef.id];
   }
-  return [cloneState(state, {
+  return [cloneMachineSnapshot(state, {
     children
   }), resolvedActorRef];
 }
@@ -685,10 +680,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 +903,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 +967,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)
       });
     }
   }
@@ -1179,7 +1173,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,173 +1251,88 @@ 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;
-      }
-      return acc;
-    }, {});
-  }
+const machineSnapshotMatches = function matches(testValue) {
+  return interpreter.matchesState(testValue, this.value);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+  return this.tags.has(tag);
+};
+const machineSnapshotCan = function 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);
+};
+const machineSnapshotToJSON = function toJSON() {
+  const {
+    configuration,
+    tags,
+    machine,
+    nextEvents,
+    toJSON,
+    can,
+    hasTag,
+    matches,
+    ...jsonValues
+  } = this;
+  return {
+    ...jsonValues,
+    tags: Array.from(tags)
+  };
+};
+const machineSnapshotNextEvents = function nextEvents() {
+  return memo(this, 'nextEvents', () => {
+    return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+  });
+};
+const machineSnapshotMeta = function nextEvents() {
+  return this.configuration.reduce((acc, stateNode) => {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+    return acc;
+  }, {});
+};
+function createMachineSnapshot(config, machine) {
+  const snapshot = {
+    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 || {},
+    // this one is generic in the target and it's hard to create a matching non-generic source signature
+    matches: machineSnapshotMatches,
+    hasTag: machineSnapshotHasTag,
+    can: machineSnapshotCan,
+    toJSON: machineSnapshotToJSON
+  };
+  Object.defineProperties(snapshot, {
+    nextEvents: {
+      get: machineSnapshotNextEvents,
+      configurable: true,
+      enumerable: true
+    },
+    meta: {
+      get: machineSnapshotMeta,
+      configurable: true,
+      enumerable: true
+    }
+  });
+  return snapshot;
 }
-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);
@@ -1435,6 +1344,11 @@ function getPersistedState(state, options) {
     machine,
     children,
     context,
+    can,
+    hasTag,
+    matches,
+    toJSON,
+    nextEvents,
     ...jsonValues
   } = state;
   const childrenJson = {};
@@ -1538,10 +1452,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 +1463,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;