xstate 3.3.2 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "3.3.2",
+  "version": "3.3.3",
   "description": "Simple JavaScript Finite State Machines and Statecharts",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -36,11 +36,11 @@
     "@types/node": "^8.9.4",
     "chai": "^4.1.2",
     "mocha": "^3.5.3",
-    "prettier": "^1.7.0",
+    "prettier": "^1.13.5",
     "scxml-test-framework": "^1.0.2",
     "ts-node": "^3.3.0",
     "tslint": "^5.7.0",
-    "typescript": "^2.8.3",
+    "typescript": "^2.9.2",
     "webpack": "^3.5.6",
     "xml-js": "^1.6.2"
   },

package/src/State.ts

@@ -3,7 +3,8 @@ import {
   ActivityMap,
   EventObject,
   Action,
-  StateInterface
+  StateInterface,
+  HistoryValue
 } from './types';
 import { STATE_DELIMITER, EMPTY_ACTIVITY_MAP } from './constants';
 
@@ -22,6 +23,7 @@ export class State implements StateInterface {
       }
       return new State(
         stateValue.value,
+        stateValue.historyValue,
         stateValue.history,
         [],
         stateValue.activities
@@ -33,6 +35,7 @@ export class State implements StateInterface {
 
   constructor(
     public value: StateValue,
+    public historyValue?: HistoryValue | undefined,
     public history?: State,
     public actions: Action[] = [],
     public activities: ActivityMap = EMPTY_ACTIVITY_MAP,

package/src/StateNode.ts

@@ -9,7 +9,8 @@ import {
   pathToStateValue,
   getActionType,
   flatMap,
-  mapFilterValues
+  mapFilterValues,
+  nestedPath
 } from './utils';
 import {
   Event,
@@ -20,7 +21,6 @@ import {
   StandardMachine,
   ParallelMachine,
   SimpleOrCompoundStateNodeConfig,
-  MachineConfig,
   ParallelMachineConfig,
   EventType,
   StandardMachineConfig,
@@ -30,14 +30,15 @@ import {
   ConditionalTransitionConfig,
   EntryExitStates,
   TargetTransitionConfig,
-  _StateTransition,
+  StateTransition,
   ActionObject,
   StateValueMap,
   MachineOptions,
   Condition,
   ConditionPredicate,
   EventObject,
-  HistoryStateNodeConfig
+  HistoryStateNodeConfig,
+  HistoryValue
 } from './types';
 import { matchesState } from './matchesState';
 import { State } from './State';
@@ -48,16 +49,11 @@ const HISTORY_KEY = '$history';
 const NULL_EVENT = '';
 const STATE_IDENTIFIER = '#';
 const isStateId = (str: string) => str[0] === STATE_IDENTIFIER;
-// const emptyActions: ActionMap = Object.freeze({
-//   onEntry: [],
-//   onExit: [],
-//   actions: []
-// });
 const defaultOptions: MachineOptions = {
   guards: {}
 };
 
-class StateNode implements StateNode {
+class StateNode {
   public key: string;
   public id: string;
   public path: string[];
@@ -106,21 +102,21 @@ class StateNode implements StateNode {
     this.initial = config.initial;
     this.parallel = !!config.parallel;
     this.states = (config.states
-      ? mapValues<
-          SimpleOrCompoundStateNodeConfig,
-          StateNode
-        >(config.states, (stateConfig, key) => {
-          const stateNode = new StateNode({
-            ...stateConfig,
-            key,
-            parent: this
-          });
-          Object.assign(this.idMap, {
-            [stateNode.id]: stateNode,
-            ...stateNode.idMap
-          });
-          return stateNode;
-        })
+      ? mapValues<SimpleOrCompoundStateNodeConfig, StateNode>(
+          config.states,
+          (stateConfig, key) => {
+            const stateNode = new StateNode({
+              ...stateConfig,
+              key,
+              parent: this
+            });
+            Object.assign(this.idMap, {
+              [stateNode.id]: stateNode,
+              ...stateNode.idMap
+            });
+            return stateNode;
+          }
+        )
       : {}) as Record<string, StateNode>;
 
     // History config
@@ -177,12 +173,12 @@ class StateNode implements StateNode {
 
     return this.events.indexOf(eventType) !== -1;
   }
-  public _transitionLeafNode(
+  private _transitionLeafNode(
     stateValue: string,
     state: State,
     event: Event,
     extendedState?: any
-  ): _StateTransition {
+  ): StateTransition {
     const stateNode = this.getStateNode(stateValue);
     const next = stateNode._next(state, event, extendedState);
 
@@ -201,7 +197,7 @@ class StateNode implements StateNode {
             stateNode,
             ...(entryExitStates
               ? Array.from(entryExitStates.exit)
-              : [] as StateNode[])
+              : ([] as StateNode[]))
           ])
         },
         actions,
@@ -211,12 +207,12 @@ class StateNode implements StateNode {
 
     return next;
   }
-  public _transitionHierarchicalNode(
+  private _transitionHierarchicalNode(
     stateValue: StateValueMap,
     state: State,
     event: Event,
     extendedState?: any
-  ): _StateTransition {
+  ): StateTransition {
     const subStateKeys = Object.keys(stateValue);
 
     const stateNode = this.getStateNode(subStateKeys[0]);
@@ -245,7 +241,7 @@ class StateNode implements StateNode {
             stateNode,
             ...(entryExitStates
               ? Array.from(entryExitStates.exit)
-              : [] as StateNode[])
+              : ([] as StateNode[]))
           ])
         },
         actions,
@@ -255,14 +251,15 @@ class StateNode implements StateNode {
 
     return next;
   }
-  public _transitionOrthogonalNode(
+  private _transitionOrthogonalNode(
     stateValue: StateValueMap,
     state: State,
     event: Event,
     extendedState?: any
-  ): _StateTransition {
+  ): StateTransition {
     const noTransitionKeys: string[] = [];
-    const transitionMap: Record<string, _StateTransition> = {};
+    const transitionMap: Record<string, StateTransition> = {};
+
     Object.keys(stateValue).forEach(subStateKey => {
       const subStateValue = stateValue[subStateKey];
 
@@ -351,12 +348,11 @@ class StateNode implements StateNode {
     const allResolvedPaths = flatMap(
       Object.keys(transitionMap).map(key => {
         const transition = transitionMap[key];
-        if (!transition.value) {
-          return toStatePaths(
-            path(this.path)(state.value)[key]
-          ).map(statePath => this.path.concat(key, statePath));
-        }
-        return transition.paths;
+        const value = transition.value || state.value;
+
+        return toStatePaths(path(this.path)(value)[key]).map(statePath =>
+          this.path.concat(key, statePath)
+        );
       })
     );
 
@@ -404,7 +400,7 @@ class StateNode implements StateNode {
     state: State,
     event: Event,
     extendedState?: any
-  ): _StateTransition {
+  ): StateTransition {
     // leaf node
     if (typeof stateValue === 'string') {
       return this._transitionLeafNode(stateValue, state, event, extendedState);
@@ -428,11 +424,11 @@ class StateNode implements StateNode {
       extendedState
     );
   }
-  public _next(
+  private _next(
     state: State,
     event: Event,
     extendedState?: any
-  ): _StateTransition {
+  ): StateTransition {
     const eventType = getEventType(event);
     const candidates = this.on[eventType];
     const actions: Action[] = this.transient
@@ -497,7 +493,7 @@ class StateNode implements StateNode {
 
     const nextStateNodes = flatMap(
       nextStateStrings.map(str =>
-        this.getRelativeStateNodes(str, state.history)
+        this.getRelativeStateNodes(str, state.historyValue)
       )
     );
 
@@ -529,7 +525,9 @@ class StateNode implements StateNode {
         pathsToStateValue(
           flatMap(
             nextStateStrings.map(str =>
-              this.getRelativeStateNodes(str, state.history).map(s => s.path)
+              this.getRelativeStateNodes(str, state.historyValue).map(
+                s => s.path
+              )
             )
           )
         )
@@ -539,7 +537,7 @@ class StateNode implements StateNode {
       paths: nextStatePaths
     };
   }
-  public _getEntryExitStates(
+  private _getEntryExitStates(
     nextStateNode: StateNode,
     internal: boolean
   ): EntryExitStates {
@@ -602,8 +600,9 @@ class StateNode implements StateNode {
     if (typeof condition === 'string') {
       if (!this.machine.options.guards[condition]) {
         throw new Error(
-          `String condition '${condition}' is not defined on machine '${this
-            .machine.id}'`
+          `String condition '${condition}' is not defined on machine '${
+            this.machine.id
+          }'`
         );
       }
 
@@ -614,7 +613,7 @@ class StateNode implements StateNode {
 
     return condFn(extendedState, eventObject, interimState);
   }
-  private _getActions(transition: _StateTransition): Action[] {
+  private _getActions(transition: StateTransition): Action[] {
     const entryExitActions = {
       entry: transition.entryExitStates
         ? flatMap(
@@ -646,7 +645,7 @@ class StateNode implements StateNode {
   }
   private _getActivities(
     state: State,
-    transition: _StateTransition
+    transition: StateTransition
   ): ActivityMap {
     if (!transition.entryExitStates) {
       return {};
@@ -654,23 +653,23 @@ class StateNode implements StateNode {
 
     const activityMap = { ...state.activities };
 
-    Array.from(transition.entryExitStates.entry).forEach(stateNode => {
+    Array.from(transition.entryExitStates.exit).forEach(stateNode => {
       if (!stateNode.activities) {
         return; // TODO: fixme
       }
 
       stateNode.activities.forEach(activity => {
-        activityMap[getActionType(activity)] = true;
+        activityMap[getActionType(activity)] = false;
       });
     });
 
-    Array.from(transition.entryExitStates.exit).forEach(stateNode => {
+    Array.from(transition.entryExitStates.entry).forEach(stateNode => {
       if (!stateNode.activities) {
         return; // TODO: fixme
       }
 
       stateNode.activities.forEach(activity => {
-        activityMap[getActionType(activity)] = false;
+        activityMap[getActionType(activity)] = true;
       });
     });
 
@@ -684,7 +683,9 @@ class StateNode implements StateNode {
     const resolvedStateValue =
       typeof state === 'string'
         ? this.resolve(pathToStateValue(this.getResolvedPath(state)))
-        : state instanceof State ? state : this.resolve(state);
+        : state instanceof State
+          ? state
+          : this.resolve(state);
 
     const eventType = getEventType(event);
 
@@ -698,6 +699,15 @@ class StateNode implements StateNode {
 
     const currentState = State.from(resolvedStateValue);
 
+    const historyValue =
+      resolvedStateValue instanceof State
+        ? resolvedStateValue.historyValue
+          ? resolvedStateValue.historyValue
+          : (this.machine.historyValue(
+              resolvedStateValue.value
+            ) as HistoryValue)
+        : (this.machine.historyValue(resolvedStateValue) as HistoryValue);
+
     const stateTransition = this._transition(
       currentState.value,
       currentState,
@@ -741,12 +751,10 @@ class StateNode implements StateNode {
       data[stateNode.id] = stateNode.data;
     });
 
-    // Dispose of previous histories to prevent memory leaks
-    delete currentState.history;
-
     const nextState = stateTransition.value
       ? new State(
           stateTransition.value,
+          StateNode.updateHistoryValue(historyValue, stateTransition.value),
           currentState,
           nonEventActions,
           activities,
@@ -760,6 +768,9 @@ class StateNode implements StateNode {
       return State.inert(currentState);
     }
 
+    // Dispose of previous histories to prevent memory leaks
+    delete currentState.history;
+
     let maybeNextState = nextState;
     while (raisedEvents.length) {
       const currentActions = maybeNextState.actions;
@@ -791,10 +802,11 @@ class StateNode implements StateNode {
           }
 
           throw new Error(
-            `State node '${stateNode.id}' shares parent '${marker.parent
-              .id}' with state node '${visitedParents.get(marker.parent)!.map(
-              a => a.id
-            )}'`
+            `State node '${stateNode.id}' shares parent '${
+              marker.parent.id
+            }' with state node '${visitedParents
+              .get(marker.parent)!
+              .map(a => a.id)}'`
           );
         }
 
@@ -815,8 +827,9 @@ class StateNode implements StateNode {
 
     if (!this.states) {
       throw new Error(
-        `Unable to retrieve child state '${stateKey}' from '${this
-          .id}'; no child states exist.`
+        `Unable to retrieve child state '${stateKey}' from '${
+          this.id
+        }'; no child states exist.`
       );
     }
 
@@ -843,6 +856,16 @@ class StateNode implements StateNode {
 
     return stateNode;
   }
+  public getStateNodeByPath(statePath: string | string[]): StateNode {
+    const arrayStatePath = toStatePath(statePath, this.delimiter);
+    let currentStateNode: StateNode = this;
+    while (arrayStatePath.length) {
+      const key = arrayStatePath.shift()!;
+      currentStateNode = currentStateNode.getStateNode(key);
+    }
+
+    return currentStateNode;
+  }
   private resolve(stateValue: StateValue): StateValue {
     if (typeof stateValue === 'string') {
       const subStateNode = this.getStateNode(stateValue);
@@ -951,7 +974,34 @@ class StateNode implements StateNode {
       }
     });
 
-    return new State(initialStateValue, undefined, actions, activityMap);
+    // TODO: deduplicate - DRY (from this.transition())
+    const raisedEvents = actions.filter(
+      action =>
+        typeof action === 'object' &&
+        (action.type === actionTypes.raise || action.type === actionTypes.null)
+    ) as ActionObject[];
+
+    const initialState = new State(
+      initialStateValue,
+      undefined,
+      undefined,
+      actions,
+      activityMap
+    );
+
+    let maybeNextState = initialState;
+    while (raisedEvents.length) {
+      const currentActions = maybeNextState.actions;
+      const raisedEvent = raisedEvents.shift()!;
+      maybeNextState = this.transition(
+        maybeNextState,
+        raisedEvent.type === actionTypes.null ? NULL_EVENT : raisedEvent.event,
+        undefined // TODO: consider initial state given external state
+      );
+      maybeNextState.actions.unshift(...currentActions);
+    }
+
+    return maybeNextState;
   }
   public get target(): StateValue | undefined {
     let target;
@@ -995,10 +1045,9 @@ class StateNode implements StateNode {
    */
   public getRelativeStateNodes(
     relativeStateId: string | string[],
-    history?: State,
+    historyValue?: HistoryValue,
     resolve: boolean = true
   ): StateNode[] {
-    const historyValue = history ? history.value : undefined;
     if (typeof relativeStateId === 'string' && isStateId(relativeStateId)) {
       const unresolvedStateNode = this.getStateNodeById(relativeStateId);
 
@@ -1039,9 +1088,15 @@ class StateNode implements StateNode {
       )
     );
   }
+  /**
+   * Retrieves state nodes from a relative path to this state node.
+   *
+   * @param relativePath The relative path from this state node
+   * @param historyValue
+   */
   public getFromRelativePath(
     relativePath: string[],
-    historyValue?: StateValue
+    historyValue?: HistoryValue
   ): StateNode[] {
     if (!relativePath.length) {
       return [this];
@@ -1060,7 +1115,10 @@ class StateNode implements StateNode {
       if (!historyValue) {
         return [this];
       }
-      const subHistoryValue = path(this.path)(historyValue);
+
+      const subHistoryValue = nestedPath<HistoryValue>(this.path, 'states')(
+        historyValue
+      ).current;
 
       if (typeof subHistoryValue === 'string') {
         return this.states[subHistoryValue].getFromRelativePath(
@@ -1070,7 +1128,7 @@ class StateNode implements StateNode {
       }
 
       return flatMap(
-        Object.keys(subHistoryValue).map(key => {
+        Object.keys(subHistoryValue!).map(key => {
           return this.states[key].getFromRelativePath(xs, historyValue);
         })
       );
@@ -1088,7 +1146,73 @@ class StateNode implements StateNode {
 
     return this.states[x].getFromRelativePath(xs, historyValue);
   }
-  private resolveHistory(historyValue?: StateValue): StateNode[] {
+  public static updateHistoryValue(
+    hist: HistoryValue,
+    stateValue: StateValue
+  ): HistoryValue {
+    function update(
+      _hist: HistoryValue,
+      _sv: StateValue
+    ): Record<string, HistoryValue | undefined> {
+      return mapValues(_hist.states, (subHist, key) => {
+        if (!subHist) {
+          return undefined;
+        }
+        const subStateValue =
+          (typeof _sv === 'string' ? undefined : _sv[key]) ||
+          (subHist ? subHist.current : undefined);
+
+        if (!subStateValue) {
+          return undefined;
+        }
+
+        return {
+          current: subStateValue,
+          states: update(subHist, subStateValue)
+        };
+      });
+    }
+    return {
+      current: stateValue,
+      states: update(hist, stateValue)
+    };
+  }
+  public historyValue(
+    relativeStateValue?: StateValue | undefined
+  ): HistoryValue | undefined {
+    if (!Object.keys(this.states).length) {
+      return undefined;
+    }
+
+    return {
+      current: relativeStateValue || this.initialStateValue,
+      states: mapFilterValues(
+        this.states,
+        (stateNode, key) => {
+          if (!relativeStateValue) {
+            return stateNode.historyValue();
+          }
+
+          const subStateValue =
+            typeof relativeStateValue === 'string'
+              ? undefined
+              : relativeStateValue[key];
+
+          return stateNode.historyValue(
+            subStateValue || stateNode.initialStateValue
+          );
+        },
+        stateNode => !stateNode.history
+      )
+    };
+  }
+  /**
+   * Resolves to the historical value(s) of the parent state node,
+   * represented by state nodes.
+   *
+   * @param historyValue
+   */
+  private resolveHistory(historyValue?: HistoryValue): StateNode[] {
     if (!this.history) {
       return [this];
     }
@@ -1099,25 +1223,27 @@ class StateNode implements StateNode {
       return this.target
         ? flatMap(
             toStatePaths(this.target).map(relativeChildPath =>
-              parent.getFromRelativePath(relativeChildPath, historyValue)
+              parent.getFromRelativePath(relativeChildPath)
             )
           )
         : this.parent!.initialStateNodes;
-    } else {
-      const subHistoryValue = path(parent.path)(historyValue);
+    }
 
-      if (typeof subHistoryValue === 'string') {
-        return [parent.getStateNode(subHistoryValue)];
-      }
+    const subHistoryValue = nestedPath<HistoryValue>(parent.path, 'states')(
+      historyValue
+    ).current;
 
-      return flatMap(
-        toStatePaths(subHistoryValue).map(subStatePath => {
-          return this.history === 'deep'
-            ? parent.getFromRelativePath(subStatePath)
-            : [parent.states[subStatePath[0]]];
-        })
-      );
+    if (typeof subHistoryValue === 'string') {
+      return [parent.getStateNode(subHistoryValue)];
     }
+
+    return flatMap(
+      toStatePaths(subHistoryValue!).map(subStatePath => {
+        return this.history === 'deep'
+          ? parent.getFromRelativePath(subStatePath)
+          : [parent.states[subStatePath[0]]];
+      })
+    );
   }
   get events(): EventType[] {
     if (this.__cache.events) {
@@ -1194,11 +1320,17 @@ class StateNode implements StateNode {
   }
 }
 
-export function Machine(
-  config: MachineConfig | ParallelMachineConfig,
-  options: MachineOptions
-): StandardMachine | ParallelMachine {
-  return new StateNode(config, options) as StandardMachine | ParallelMachine;
+export function Machine<
+  T extends StandardMachineConfig | ParallelMachineConfig
+>(
+  config: T,
+  options?: MachineOptions
+): T extends ParallelMachineConfig
+  ? ParallelMachine
+  : T extends StandardMachineConfig ? StandardMachine : never {
+  return new StateNode(config, options) as T extends ParallelMachineConfig
+    ? ParallelMachine
+    : T extends StandardMachineConfig ? StandardMachine : never;
 }
 
 export { StateNode };

package/src/graph.ts

@@ -16,20 +16,21 @@ const EMPTY_MAP = {};
 
 export function getNodes(node: StateNode): StateNode[] {
   const { states } = node;
-  const nodes = Object.keys(
-    states
-  ).reduce((accNodes: StateNode[], stateKey) => {
-    const subState = states[stateKey];
-    const subNodes = getNodes(states[stateKey]);
-
-    accNodes.push(subState, ...subNodes);
-    return accNodes;
-  }, []);
+  const nodes = Object.keys(states).reduce(
+    (accNodes: StateNode[], stateKey) => {
+      const subState = states[stateKey];
+      const subNodes = getNodes(states[stateKey]);
+
+      accNodes.push(subState, ...subNodes);
+      return accNodes;
+    },
+    []
+  );
 
   return nodes;
 }
 
-function getEventEdges(node: StateNode, event: string): Edge[] {
+export function getEventEdges(node: StateNode, event: string): Edge[] {
   const transitions = node.on[event]!;
 
   return flatMap(
@@ -55,10 +56,11 @@ function getEventEdges(node: StateNode, event: string): Edge[] {
   );
 }
 
-export function getEdges(node: StateNode): Edge[] {
+export function getEdges(node: StateNode, options?: { deep: boolean }): Edge[] {
+  const { deep = true } = options || {};
   const edges: Edge[] = [];
 
-  if (node.states) {
+  if (node.states && deep) {
     Object.keys(node.states).forEach(stateKey => {
       edges.push(...getEdges(node.states[stateKey]));
     });