xstate 5.0.0-beta.44 → 5.0.0-beta.46

package/dist/{raise-ed700d14.development.cjs.js → raise-a9e7e31c.development.cjs.js}

@@ -321,6 +321,9 @@ function resolveReferencedActor(machine, src) {
   }
   return machine.implementations.actors[src];
 }
+function getAllOwnEventDescriptors(snapshot) {
+  return [...new Set(flatten([...snapshot._nodes.map(sn => sn.ownEvents)]))];
+}
 
 const $$ACTOR_TYPE = 1;
 // those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
@@ -347,32 +350,6 @@ const defaultOptions = {
  * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
  */
 class Actor {
-  /**
-   * The current internal state of the actor.
-   */
-
-  /**
-   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
-   */
-
-  /**
-   * The unique identifier for this actor relative to its parent.
-   */
-
-  /** @internal */
-
-  // Actor Ref
-
-  // TODO: add typings for system
-
-  /**
-   * The globally unique process ID for this invocation.
-   */
-
-  /**
-   * The system to which this actor belongs.
-   */
-
   /**
    * Creates a new actor instance for the given logic with the provided options, if any.
    *
@@ -381,23 +358,43 @@ class Actor {
    */
   constructor(logic, options) {
     this.logic = logic;
+    /**
+     * The current internal state of the actor.
+     */
     this._state = void 0;
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     */
     this.clock = void 0;
     this.options = void 0;
+    /**
+     * The unique identifier for this actor relative to its parent.
+     */
     this.id = void 0;
     this.mailbox = new Mailbox(this._process.bind(this));
     this.delayedEventsMap = {};
     this.observers = new Set();
     this.logger = void 0;
+    /** @internal */
     this._processingStatus = ProcessingStatus.NotStarted;
+    // Actor Ref
     this._parent = void 0;
+    this._syncSnapshot = void 0;
     this.ref = void 0;
+    // TODO: add typings for system
     this._actorScope = void 0;
     this._systemId = void 0;
+    /**
+     * The globally unique process ID for this invocation.
+     */
     this.sessionId = void 0;
+    /**
+     * The system to which this actor belongs.
+     */
     this.system = void 0;
     this._doneEvent = void 0;
     this.src = void 0;
+    // array of functions to defer
     this._deferred = [];
     const resolvedOptions = {
       ...defaultOptions,
@@ -407,6 +404,7 @@ class Actor {
       clock,
       logger,
       parent,
+      syncSnapshot,
       id,
       systemId,
       inspect
@@ -421,6 +419,7 @@ class Actor {
     this.logger = logger;
     this.clock = clock;
     this._parent = parent;
+    this._syncSnapshot = syncSnapshot;
     this.options = resolvedOptions;
     this.src = resolvedOptions.src ?? logic;
     this.ref = this;
@@ -460,9 +459,6 @@ class Actor {
   _initState(persistedState) {
     this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
   }
-
-  // array of functions to defer
-
   update(snapshot, event) {
     // Update state
     this._state = snapshot;
@@ -579,6 +575,19 @@ class Actor {
       // Do not restart the service if it is already started
       return this;
     }
+    if (this._syncSnapshot) {
+      this.subscribe({
+        next: snapshot => {
+          if (snapshot.status === 'active') {
+            this._parent.send({
+              type: `xstate.snapshot.${this.id}`,
+              snapshot
+            });
+          }
+        },
+        error: () => {}
+      });
+    }
     this.system._register(this.sessionId, this);
     if (this._systemId) {
       this.system._set(this._systemId, this);
@@ -864,20 +873,6 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-const cache = new WeakMap();
-function memo(object, key, fn) {
-  let memoizedData = cache.get(object);
-  if (!memoizedData) {
-    memoizedData = {
-      [key]: fn()
-    };
-    cache.set(object, memoizedData);
-  } else if (!(key in memoizedData)) {
-    memoizedData[key] = fn();
-  }
-  return memoizedData[key];
-}
-
 function resolveCancel(_, state, actionArgs, actionParams, {
   sendId
 }) {
@@ -922,6 +917,7 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
+      syncSnapshot,
       systemId,
       input: typeof input === 'function' ? input({
         context: state.context,
@@ -929,19 +925,6 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
         self: actorScope?.self
       }) : input
     });
-    if (syncSnapshot) {
-      actorRef.subscribe({
-        next: snapshot => {
-          if (snapshot.status === 'active') {
-            actorScope.self.send({
-              type: `xstate.snapshot.${id}`,
-              snapshot
-            });
-          }
-        },
-        error: () => {}
-      });
-    }
   }
   if (!actorRef) {
     console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
@@ -1060,7 +1043,7 @@ function checkStateIn(state, _, {
 }) {
   if (typeof stateValue === 'string' && isStateId(stateValue)) {
     const target = state.machine.getStateNodeById(stateValue);
-    return state.configuration.some(sn => sn === target);
+    return state._nodes.some(sn => sn === target);
   }
   return state.matches(stateValue);
 }
@@ -1179,26 +1162,25 @@ function getProperAncestors(stateNode, toStateNode) {
   }
   return ancestors;
 }
-function getConfiguration(stateNodes) {
-  const configuration = new Set(stateNodes);
-  const configurationSet = new Set(stateNodes);
-  const adjList = getAdjList(configurationSet);
+function getAllStateNodes(stateNodes) {
+  const nodeSet = new Set(stateNodes);
+  const adjList = getAdjList(nodeSet);
 
   // add descendants
-  for (const s of configuration) {
+  for (const s of nodeSet) {
     // if previously active, add existing child nodes
     if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodesWithTheirAncestors(s).forEach(sn => configurationSet.add(sn));
+      getInitialStateNodesWithTheirAncestors(s).forEach(sn => nodeSet.add(sn));
     } else {
       if (s.type === 'parallel') {
         for (const child of getChildren(s)) {
           if (child.type === 'history') {
             continue;
           }
-          if (!configurationSet.has(child)) {
+          if (!nodeSet.has(child)) {
             const initialStates = getInitialStateNodesWithTheirAncestors(child);
             for (const initialStateNode of initialStates) {
-              configurationSet.add(initialStateNode);
+              nodeSet.add(initialStateNode);
             }
           }
         }
@@ -1207,14 +1189,14 @@ function getConfiguration(stateNodes) {
   }
 
   // add all ancestors
-  for (const s of configurationSet) {
+  for (const s of nodeSet) {
     let m = s.parent;
     while (m) {
-      configurationSet.add(m);
+      nodeSet.add(m);
       m = m.parent;
     }
   }
-  return configurationSet;
+  return nodeSet;
 }
 function getValueFromAdj(baseNode, adjList) {
   const childStateNodes = adjList.get(baseNode);
@@ -1238,9 +1220,9 @@ function getValueFromAdj(baseNode, adjList) {
   }
   return stateValue;
 }
-function getAdjList(configuration) {
+function getAdjList(stateNodes) {
   const adjList = new Map();
-  for (const s of configuration) {
+  for (const s of stateNodes) {
     if (!adjList.has(s)) {
       adjList.set(s, []);
     }
@@ -1253,16 +1235,16 @@ function getAdjList(configuration) {
   }
   return adjList;
 }
-function getStateValue(rootNode, configuration) {
-  const config = getConfiguration(configuration);
+function getStateValue(rootNode, stateNodes) {
+  const config = getAllStateNodes(stateNodes);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-function isInFinalState(configuration, stateNode) {
+function isInFinalState(stateNodeSet, stateNode) {
   if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.has(s));
+    return getChildren(stateNode).some(s => s.type === 'final' && stateNodeSet.has(s));
   }
   if (stateNode.type === 'parallel') {
-    return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
+    return getChildren(stateNode).every(sn => isInFinalState(stateNodeSet, sn));
   }
   return stateNode.type === 'final';
 }
@@ -1633,13 +1615,13 @@ function hasIntersection(s1, s2) {
   }
   return false;
 }
-function removeConflictingTransitions(enabledTransitions, configuration, historyValue) {
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, historyValue) {
   const filteredTransitions = new Set();
   for (const t1 of enabledTransitions) {
     let t1Preempted = false;
     const transitionsToRemove = new Set();
     for (const t2 of filteredTransitions) {
-      if (hasIntersection(computeExitSet([t1], configuration, historyValue), computeExitSet([t2], configuration, historyValue))) {
+      if (hasIntersection(computeExitSet([t1], stateNodeSet, historyValue), computeExitSet([t2], stateNodeSet, historyValue))) {
         if (isDescendant(t1.source, t2.source)) {
           transitionsToRemove.add(t2);
         } else {
@@ -1706,7 +1688,7 @@ function getTransitionDomain(transition, historyValue) {
   }
   return transition.source.machine.root;
 }
-function computeExitSet(transitions, configuration, historyValue) {
+function computeExitSet(transitions, stateNodeSet, historyValue) {
   const statesToExit = new Set();
   for (const t of transitions) {
     if (t.target?.length) {
@@ -1714,7 +1696,7 @@ function computeExitSet(transitions, configuration, historyValue) {
       if (t.reenter && t.source === domain) {
         statesToExit.add(domain);
       }
-      for (const stateNode of configuration) {
+      for (const stateNode of stateNodeSet) {
         if (isDescendant(stateNode, domain)) {
           statesToExit.add(stateNode);
         }
@@ -1723,12 +1705,12 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
-function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
-  if (previousConfiguration.length !== nextConfigurationSet.size) {
+function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
+  if (prevStateNodes.length !== nextStateNodeSet.size) {
     return false;
   }
-  for (const node of previousConfiguration) {
-    if (!nextConfigurationSet.has(node)) {
+  for (const node of prevStateNodes) {
+    if (!nextStateNodeSet.has(node)) {
       return false;
     }
   }
@@ -1742,31 +1724,31 @@ function microstep(transitions, currentState, actorScope, event, isInitial, inte
   if (!transitions.length) {
     return currentState;
   }
-  const mutConfiguration = new Set(currentState.configuration);
+  const mutStateNodeSet = new Set(currentState._nodes);
   let historyValue = currentState.historyValue;
-  const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
+  const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
   let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, historyValue, internalQueue);
+    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue);
   }
 
   // Execute transition content
   nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
-  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
-  const nextConfiguration = [...mutConfiguration];
+  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+  const nextStateNodes = [...mutStateNodeSet];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+    if (historyValue === currentState.historyValue && areStateNodeCollectionsEqual(currentState._nodes, mutStateNodeSet)) {
       return nextState;
     }
     return cloneMachineSnapshot(nextState, {
-      configuration: nextConfiguration,
+      _nodes: nextStateNodes,
       historyValue
     });
   } catch (e) {
@@ -1782,7 +1764,7 @@ function getMachineOutput(state, event, actorScope, rootNode, rootCompletionNode
   const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
   return resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
 }
-function enterStates(currentState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+function enterStates(currentState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
   // those are states that were directly targeted or indirectly targeted by the explicit target
@@ -1797,7 +1779,7 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutCo
   }
   const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
-    mutConfiguration.add(stateNodeToEnter);
+    mutStateNodeSet.add(stateNodeToEnter);
     const actions = [];
 
     // Add entry actions
@@ -1820,7 +1802,7 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutCo
       if (parent?.type === 'compound') {
         internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
       }
-      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
         internalQueue.push(createDoneStateEvent(ancestorMarker.id));
         rootCompletionNode = ancestorMarker;
@@ -1930,9 +1912,9 @@ function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultE
 function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
   addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
 }
-function exitStates(currentState, event, actorScope, transitions, mutConfiguration, historyValue, internalQueue) {
+function exitStates(currentState, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue) {
   let nextState = currentState;
-  const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
+  const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
   let changedHistory;
 
@@ -1950,12 +1932,12 @@ function exitStates(currentState, event, actorScope, transitions, mutConfigurati
       changedHistory ??= {
         ...historyValue
       };
-      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory[historyNode.id] = Array.from(mutStateNodeSet).filter(predicate);
     }
   }
   for (const s of statesToExit) {
     nextState = resolveActionsAndContext(nextState, event, actorScope, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
-    mutConfiguration.delete(s);
+    mutStateNodeSet.delete(s);
   }
   return [nextState, changedHistory || historyValue];
 }
@@ -2087,7 +2069,7 @@ function selectTransitions(event, nextState) {
 }
 function selectEventlessTransitions(nextState, event) {
   const enabledTransitionSet = new Set();
-  const atomicStates = nextState.configuration.filter(isAtomicStateNode);
+  const atomicStates = nextState._nodes.filter(isAtomicStateNode);
   for (const stateNode of atomicStates) {
     loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, undefined))) {
       if (!s.always) {
@@ -2101,7 +2083,7 @@ function selectEventlessTransitions(nextState, event) {
       }
     }
   }
-  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState.configuration), nextState.historyValue);
+  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState._nodes), nextState.historyValue);
 }
 
 /**
@@ -2110,8 +2092,8 @@ function selectEventlessTransitions(nextState, event) {
  * @param stateValue The partial state value to resolve.
  */
 function resolveStateValue(rootNode, stateValue) {
-  const configuration = getConfiguration(getStateNodes(rootNode, stateValue));
-  return getStateValue(rootNode, [...configuration]);
+  const allStateNodes = getAllStateNodes(getStateNodes(rootNode, stateValue));
+  return getStateValue(rootNode, [...allStateNodes]);
 }
 
 function isMachineSnapshot(value) {
@@ -2134,10 +2116,10 @@ const machineSnapshotCan = function can(event) {
 };
 const machineSnapshotToJSON = function toJSON() {
   const {
-    configuration,
+    _nodes: nodes,
     tags,
     machine,
-    nextEvents,
+    getMeta,
     toJSON,
     can,
     hasTag,
@@ -2149,13 +2131,8 @@ const machineSnapshotToJSON = function toJSON() {
     tags: Array.from(tags)
   };
 };
-const machineSnapshotNextEvents = function nextEvents() {
-  return memo(this, 'nextEvents', () => {
-    return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-  });
-};
-const machineSnapshotMeta = function nextEvents() {
-  return this.configuration.reduce((acc, stateNode) => {
+const machineSnapshotGetMeta = function getMeta() {
+  return this._nodes.reduce((acc, stateNode) => {
     if (stateNode.meta !== undefined) {
       acc[stateNode.id] = stateNode.meta;
     }
@@ -2163,48 +2140,34 @@ const machineSnapshotMeta = function nextEvents() {
   }, {});
 };
 function createMachineSnapshot(config, machine) {
-  const snapshot = {
+  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(flatten(config.configuration.map(sn => sn.tags))),
+    _nodes: config._nodes,
+    value: getStateValue(machine.root, config._nodes),
+    tags: new Set(flatten(config._nodes.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,
+    getMeta: machineSnapshotGetMeta,
     toJSON: machineSnapshotToJSON
   };
-  Object.defineProperties(snapshot, {
-    nextEvents: {
-      get: machineSnapshotNextEvents,
-      configurable: true,
-      enumerable: true
-    },
-    meta: {
-      get: machineSnapshotMeta,
-      configurable: true,
-      enumerable: true
-    }
-  });
-  return snapshot;
 }
 function cloneMachineSnapshot(state, config = {}) {
-  return createMachineSnapshot(
-  // TODO: it's wasteful that this spread triggers getters
-  {
+  return createMachineSnapshot({
     ...state,
     ...config
   }, state.machine);
 }
 function getPersistedState(state, options) {
   const {
-    configuration,
+    _nodes: nodes,
     tags,
     machine,
     children,
@@ -2212,8 +2175,8 @@ function getPersistedState(state, options) {
     can,
     hasTag,
     matches,
+    getMeta,
     toJSON,
-    nextEvents,
     ...jsonValues
   } = state;
   const childrenJson = {};
@@ -2225,7 +2188,8 @@ function getPersistedState(state, options) {
     childrenJson[id] = {
       state: child.getPersistedState(options),
       src: child.src,
-      systemId: child._systemId
+      systemId: child._systemId,
+      syncSnapshot: child._syncSnapshot
     };
   }
   const persisted = {
@@ -2336,8 +2300,9 @@ exports.evaluateGuard = evaluateGuard;
 exports.formatInitialTransition = formatInitialTransition;
 exports.formatTransition = formatTransition;
 exports.formatTransitions = formatTransitions;
+exports.getAllOwnEventDescriptors = getAllOwnEventDescriptors;
+exports.getAllStateNodes = getAllStateNodes;
 exports.getCandidates = getCandidates;
-exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedState = getPersistedState;
@@ -2351,7 +2316,6 @@ exports.isStateId = isStateId;
 exports.macrostep = macrostep;
 exports.mapValues = mapValues;
 exports.matchesState = matchesState;
-exports.memo = memo;
 exports.microstep = microstep;
 exports.not = not;
 exports.or = or;