xstate 5.0.0-beta.44 → 5.0.0-beta.45

package/dist/{raise-5854eaca.esm.js → raise-2b5a4e4c.esm.js}

@@ -386,6 +386,7 @@ class Actor {
     this.logger = void 0;
     this._processingStatus = ProcessingStatus.NotStarted;
     this._parent = void 0;
+    this._syncSnapshot = void 0;
     this.ref = void 0;
     this._actorScope = void 0;
     this._systemId = void 0;
@@ -402,6 +403,7 @@ class Actor {
       clock,
       logger,
       parent,
+      syncSnapshot,
       id,
       systemId,
       inspect
@@ -416,6 +418,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;
@@ -574,6 +577,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);
@@ -851,20 +867,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
 }) {
@@ -906,6 +908,7 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
+      syncSnapshot,
       systemId,
       input: typeof input === 'function' ? input({
         context: state.context,
@@ -913,19 +916,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: () => {}
-      });
-    }
   }
   return [cloneMachineSnapshot(state, {
     children: {
@@ -1035,7 +1025,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);
 }
@@ -1146,26 +1136,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);
             }
           }
         }
@@ -1174,14 +1163,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);
@@ -1205,9 +1194,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, []);
     }
@@ -1220,16 +1209,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';
 }
@@ -1589,13 +1578,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 {
@@ -1662,7 +1651,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) {
@@ -1670,7 +1659,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);
         }
@@ -1679,12 +1668,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;
     }
   }
@@ -1698,31 +1687,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) {
@@ -1738,7 +1727,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
@@ -1753,7 +1742,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
@@ -1776,7 +1765,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;
@@ -1886,9 +1875,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;
 
@@ -1906,12 +1895,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];
 }
@@ -2040,7 +2029,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) {
@@ -2054,7 +2043,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);
 }
 
 /**
@@ -2063,8 +2052,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) {
@@ -2084,10 +2073,11 @@ const machineSnapshotCan = function can(event) {
 };
 const machineSnapshotToJSON = function toJSON() {
   const {
-    configuration,
+    _nodes: nodes,
     tags,
     machine,
-    nextEvents,
+    getNextEvents,
+    getMeta,
     toJSON,
     can,
     hasTag,
@@ -2099,13 +2089,11 @@ 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 machineSnapshotGetNextEvents = function getNextEvents() {
+  return [...new Set(flatten([...this._nodes.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;
     }
@@ -2113,48 +2101,35 @@ 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,
+    getNextEvents: machineSnapshotGetNextEvents,
+    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,
@@ -2162,8 +2137,9 @@ function getPersistedState(state, options) {
     can,
     hasTag,
     matches,
+    getNextEvents,
+    getMeta,
     toJSON,
-    nextEvents,
     ...jsonValues
   } = state;
   const childrenJson = {};
@@ -2172,7 +2148,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 = {
@@ -2261,4 +2238,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, getPersistedState as A, resolveReferencedActor as B, createActor as C, Actor as D, interpret as E, isMachineSnapshot as F, matchesState as G, pathToStateValue as H, toObserver as I, and as J, not as K, or as L, stateIn as M, NULL_EVENT as N, cancel as O, raise as P, stop as Q, spawn as R, STATE_DELIMITER as S, ProcessingStatus as T, createErrorActorEvent as U, XSTATE_ERROR as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, memo as c, createInvokeId as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, formatInitialTransition as h, getCandidates as i, getConfiguration as j, getStateNodes as k, createMachineSnapshot as l, mapValues as m, isInFinalState as n, isErrorActorEvent as o, cloneMachineSnapshot as p, macrostep as q, resolveStateValue as r, transitionNode as s, toArray as t, resolveActionsAndContext as u, createInitEvent as v, microstep as w, getInitialStateNodes as x, isStateId as y, getStateNodeByPath as z };
+export { $$ACTOR_TYPE as $, resolveReferencedActor as A, createActor as B, Actor as C, interpret as D, isMachineSnapshot as E, matchesState as F, pathToStateValue as G, toObserver as H, and as I, not as J, or as K, stateIn as L, cancel as M, NULL_EVENT as N, raise as O, stop as P, spawn as Q, ProcessingStatus as R, STATE_DELIMITER as S, createErrorActorEvent as T, XSTATE_ERROR as U, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, isErrorActorEvent as n, cloneMachineSnapshot as o, macrostep as p, transitionNode as q, resolveStateValue as r, resolveActionsAndContext as s, toArray as t, createInitEvent as u, microstep as v, getInitialStateNodes as w, isStateId as x, getStateNodeByPath as y, getPersistedState as z };