xstate 3.2.1 → 3.3.3

package/src/graph.ts

@@ -1,5 +1,5 @@
 import { StateNode } from './index';
-import { toStateValue, getActionType } from './utils';
+import { toStateValue, getActionType, flatMap } from './utils';
 import {
   StateValue,
   Machine,
@@ -16,37 +16,51 @@ 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]);
+  const nodes = Object.keys(states).reduce(
+    (accNodes: StateNode[], stateKey) => {
+      const subState = states[stateKey];
+      const subNodes = getNodes(states[stateKey]);
 
-    accNodes.push(subState, ...subNodes);
-    return accNodes;
-  }, []);
+      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 transitions.map(transition => {
-    return {
-      source: node,
-      target: node.parent!.getState(transition.target)!,
-      event,
-      actions: transition.actions ? transition.actions.map(getActionType) : [],
-      cond: transition.cond
-    };
-  });
+  return flatMap(
+    transitions.map(transition => {
+      const targets = ([] as string[]).concat(transition.target);
+      return targets.map(target => {
+        const targetNode = node.getRelativeStateNodes(
+          target,
+          undefined,
+          false
+        )[0];
+        return {
+          source: node,
+          target: targetNode,
+          event,
+          actions: transition.actions
+            ? transition.actions.map(getActionType)
+            : [],
+          cond: transition.cond
+        };
+      });
+    })
+  );
 }
 
-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]));
     });
@@ -59,7 +73,10 @@ export function getEdges(node: StateNode): Edge[] {
   return edges;
 }
 
-export function getAdjacencyMap(node: Machine): AdjacencyMap {
+export function getAdjacencyMap(
+  node: Machine,
+  extendedState?: any
+): AdjacencyMap {
   const adjacency: AdjacencyMap = {};
 
   const events = node.events;
@@ -74,7 +91,7 @@ export function getAdjacencyMap(node: Machine): AdjacencyMap {
     adjacency[stateKey] = {};
 
     for (const event of events) {
-      const nextState = node.transition(stateValue, event);
+      const nextState = node.transition(stateValue, event, extendedState);
       adjacency[stateKey][event] = { state: nextState.value };
 
       findAdjacencies(nextState.value);
@@ -86,11 +103,14 @@ export function getAdjacencyMap(node: Machine): AdjacencyMap {
   return adjacency;
 }
 
-export function getShortestPaths(machine: Machine): PathMap {
+export function getShortestPaths(
+  machine: Machine,
+  extendedState?: any
+): PathMap {
   if (!machine.states) {
     return EMPTY_MAP;
   }
-  const adjacency = getAdjacencyMap(machine);
+  const adjacency = getAdjacencyMap(machine, extendedState);
   const initialStateId = JSON.stringify(machine.initialState.value);
   const pathMap: PathMap = {
     [initialStateId]: []
@@ -148,20 +168,26 @@ export function getShortestPaths(machine: Machine): PathMap {
   return pathMap;
 }
 
-export function getShortestPathsAsArray(machine: Machine): PathItem[] {
-  const result = getShortestPaths(machine);
+export function getShortestPathsAsArray(
+  machine: Machine,
+  extendedState?: any
+): PathItem[] {
+  const result = getShortestPaths(machine, extendedState);
   return Object.keys(result).map(key => ({
     state: JSON.parse(key),
     path: result[key]
   }));
 }
 
-export function getSimplePaths(machine: Machine): PathsMap {
+export function getSimplePaths(
+  machine: Machine,
+  extendedState?: any
+): PathsMap {
   if (!machine.states) {
     return EMPTY_MAP;
   }
 
-  const adjacency = getAdjacencyMap(machine);
+  const adjacency = getAdjacencyMap(machine, extendedState);
   const visited = new Set();
   const path: Segment[] = [];
   const paths: PathsMap = {};
@@ -202,8 +228,11 @@ export function getSimplePaths(machine: Machine): PathsMap {
   return paths;
 }
 
-export function getSimplePathsAsArray(machine: Machine): PathsItem[] {
-  const result = getSimplePaths(machine);
+export function getSimplePathsAsArray(
+  machine: Machine,
+  extendedState?: any
+): PathsItem[] {
+  const result = getSimplePaths(machine, extendedState);
   return Object.keys(result).map(key => ({
     state: JSON.parse(key),
     paths: result[key]

package/src/scxml.ts

@@ -62,25 +62,54 @@ function stateNodeToSCXML(stateNode: StateNode) {
         return stateNodeToSCXML(subStateNode);
       }),
       ...Object.keys(stateNode.on)
-        .map((event): XMLElement[] => {
-          const transition = stateNode.on![event];
+        .map(
+          (event): XMLElement[] => {
+            const transition = stateNode.on![event];
 
-          if (!transition) {
-            return [];
-          }
+            if (!transition) {
+              return [];
+            }
+
+            if (Array.isArray(transition)) {
+              return transition.map(targetTransition => {
+                return {
+                  type: 'element',
+                  name: 'transition',
+                  attributes: {
+                    ...(event ? { event } : undefined),
+                    target: stateNode.parent!.getRelativeStateNodes(
+                      targetTransition.target
+                    )[0]!.id, // TODO: fixme
+                    ...(targetTransition.cond
+                      ? { cond: targetTransition.cond.toString() }
+                      : undefined)
+                  },
+                  elements: targetTransition.actions
+                    ? targetTransition.actions.map(action => ({
+                        type: 'element',
+                        name: 'send',
+                        attributes: {
+                          event: getActionType(action)
+                        }
+                      }))
+                    : undefined
+                };
+              });
+            }
+
+            return Object.keys(transition).map(target => {
+              const targetTransition = transition[target];
 
-          if (Array.isArray(transition)) {
-            return transition.map(targetTransition => {
               return {
                 type: 'element',
                 name: 'transition',
                 attributes: {
-                  ...event ? { event } : undefined,
-                  target: stateNode.parent!.getState(targetTransition.target)!
-                    .id,
-                  ...targetTransition.cond
+                  ...(event ? { event } : undefined),
+                  target: stateNode.parent!.getRelativeStateNodes(target)![0]
+                    .id, // TODO: fixme
+                  ...(targetTransition.cond
                     ? { cond: targetTransition.cond.toString() }
-                    : undefined
+                    : undefined)
                 },
                 elements: targetTransition.actions
                   ? targetTransition.actions.map(action => ({
@@ -94,32 +123,7 @@ function stateNodeToSCXML(stateNode: StateNode) {
               };
             });
           }
-
-          return Object.keys(transition).map(target => {
-            const targetTransition = transition[target];
-
-            return {
-              type: 'element',
-              name: 'transition',
-              attributes: {
-                ...event ? { event } : undefined,
-                target: stateNode.parent!.getState(target)!.id,
-                ...targetTransition.cond
-                  ? { cond: targetTransition.cond.toString() }
-                  : undefined
-              },
-              elements: targetTransition.actions
-                ? targetTransition.actions.map(action => ({
-                    type: 'element',
-                    name: 'send',
-                    attributes: {
-                      event: getActionType(action)
-                    }
-                  }))
-                : undefined
-            };
-          });
-        })
+        )
         .reduce((a, b) => a.concat(b))
     ].filter(Boolean) as XMLElement[]
   };
@@ -210,10 +214,37 @@ function toConfig(
   let initial = parallel ? undefined : nodeJson.attributes!.initial;
   let states: Record<string, any>;
   let on: Record<string, any>;
+  const { elements } = nodeJson;
+
+  switch (nodeJson.name) {
+    case 'history': {
+      if (!elements) {
+        return {
+          id,
+          history: nodeJson.attributes!.type || 'shallow'
+        };
+      }
+
+      const [transitionElement] = elements.filter(
+        element => element.name === 'transition'
+      );
+
+      return {
+        id,
+        history: nodeJson.attributes!.type || 'shallow',
+        target: `#${transitionElement.attributes!.target}`
+      };
+    }
+    default:
+      break;
+  }
 
   if (nodeJson.elements) {
     const stateElements = nodeJson.elements.filter(
-      element => element.name === 'state' || element.name === 'parallel'
+      element =>
+        element.name === 'state' ||
+        element.name === 'parallel' ||
+        element.name === 'history'
     );
 
     const transitionElements = nodeJson.elements.filter(
@@ -248,12 +279,12 @@ function toConfig(
       (values: XMLElement[]) => {
         return values.map(value => ({
           target: `#${value.attributes!.target}`,
-          ...value.elements ? executableContent(value.elements) : undefined,
-          ...value.attributes!.cond
+          ...(value.elements ? executableContent(value.elements) : undefined),
+          ...(value.attributes!.cond
             ? {
                 cond: evalCond(value.attributes!.cond as string)
               }
-            : undefined
+            : undefined)
         }));
       }
     );
@@ -283,18 +314,18 @@ function toConfig(
     return {
       id,
       delimiter: options.delimiter,
-      ...initial ? { initial } : undefined,
-      ...parallel ? { parallel } : undefined,
-      ...stateElements.length
+      ...(initial ? { initial } : undefined),
+      ...(parallel ? { parallel } : undefined),
+      ...(stateElements.length
         ? {
             states: mapValues(states, (state, key) =>
               toConfig(state, key, options)
             )
           }
-        : undefined,
-      ...transitionElements.length ? { on } : undefined,
-      ...onEntry ? { onEntry } : undefined,
-      ...onExit ? { onExit } : undefined
+        : undefined),
+      ...(transitionElements.length ? { on } : undefined),
+      ...(onEntry ? { onEntry } : undefined),
+      ...(onExit ? { onExit } : undefined)
     };
   }
 

package/src/types.ts

@@ -25,12 +25,24 @@ export interface StateValueMap {
 
 export type StateValue = string | StateValueMap;
 
-export type Condition = (extendedState: any, event?: EventObject) => boolean;
+export interface HistoryValue {
+  states: Record<string, HistoryValue | undefined>;
+  current: StateValue | undefined;
+}
+
+export type ConditionPredicate = (
+  extendedState: any,
+  event: EventObject,
+  microstepState: StateValue
+) => boolean;
+
+export type Condition = string | ConditionPredicate;
 
 export interface TransitionConfig {
-  cond?: (extendedState: any, event: EventObject) => boolean;
+  cond?: Condition;
   actions?: Action[];
   in?: StateValue;
+  internal?: boolean;
 }
 
 export interface TargetTransitionConfig extends TransitionConfig {
@@ -50,6 +62,12 @@ export interface StateNodeConfig {
   key?: string;
   initial?: string | undefined;
   parallel?: boolean | undefined;
+  /**
+   * Indicates whether the state node is a history state node, and what
+   * type of history:
+   * shallow, deep, true (shallow), false (none), undefined (none)
+   */
+  history?: 'shallow' | 'deep' | boolean | undefined;
   states?: Record<string, SimpleOrCompoundStateNodeConfig> | undefined;
   on?: Record<string, Transition | undefined>;
   onEntry?: Action | Action[];
@@ -67,19 +85,29 @@ export interface SimpleStateNodeConfig extends StateNodeConfig {
   states?: undefined;
 }
 
+export interface HistoryStateNodeConfig extends SimpleStateNodeConfig {
+  history: 'shallow' | 'deep' | true;
+  target: StateValue | undefined;
+}
+
 export interface CompoundStateNodeConfig extends StateNodeConfig {
   initial?: string;
   parallel?: boolean;
   states: Record<string, SimpleOrCompoundStateNodeConfig>;
+  history?: false | undefined;
 }
 
 export type SimpleOrCompoundStateNodeConfig =
   | CompoundStateNodeConfig
   | SimpleStateNodeConfig;
 
+export interface MachineOptions {
+  guards: Record<string, ConditionPredicate>;
+}
 export interface MachineConfig extends CompoundStateNodeConfig {
   key?: string;
   strict?: boolean;
+  history?: false | undefined;
 }
 export interface StandardMachineConfig extends MachineConfig {
   initial: string;
@@ -89,7 +117,6 @@ export interface StandardMachineConfig extends MachineConfig {
 export interface ParallelMachineConfig extends MachineConfig {
   initial?: undefined;
   parallel: true;
-  states: Record<string, CompoundStateNodeConfig>;
 }
 
 export interface EntryExitEffectMap {
@@ -102,6 +129,8 @@ export interface StateNode {
   id: string;
   initial: string | undefined;
   parallel: boolean;
+  transient: boolean;
+  history: false | 'shallow' | 'deep';
   states: Record<string, StateNode>;
   on?: Record<string, Transition>;
   onEntry?: Action | Action[];
@@ -112,6 +141,7 @@ export interface StateNode {
 
 export interface ComplexStateNode extends StateNode {
   initial: string;
+  history: false;
 }
 
 export interface LeafStateNode extends StateNode {
@@ -121,6 +151,11 @@ export interface LeafStateNode extends StateNode {
   parent: StateNode;
 }
 
+export interface HistoryStateNode extends StateNode {
+  history: 'shallow' | 'deep';
+  target: StateValue | undefined;
+}
+
 export interface Machine extends StateNode {
   id: string;
   initial: string | undefined;
@@ -145,6 +180,11 @@ export interface ActionMap {
   onExit: Action[];
 }
 
+export interface EntryExitStates {
+  entry: Set<StateNode>;
+  exit: Set<StateNode>;
+}
+
 export interface ActivityMap {
   [activityKey: string]: boolean;
 }
@@ -154,11 +194,12 @@ export type MaybeStateValueActionsTuple = [
   ActivityMap | undefined
 ];
 
+// tslint:disable-next-line:class-name
 export interface StateTransition {
-  statePaths: string[][];
-  actions: ActionMap;
-  activities: ActivityMap | undefined;
-  events: EventObject[];
+  value: StateValue | undefined;
+  entryExitStates: EntryExitStates | undefined;
+  actions: Action[];
+  paths: string[][];
 }
 
 export interface TransitionData {

package/src/utils.ts

@@ -16,7 +16,9 @@ export function getActionType(action: Action): ActionType {
   try {
     return typeof action === 'string' || typeof action === 'number'
       ? `${action}`
-      : typeof action === 'function' ? action.name : action.type;
+      : typeof action === 'function'
+        ? action.name
+        : action.type;
   } catch (e) {
     throw new Error(
       'Events must be strings or objects with a string event.type property.'
@@ -89,34 +91,73 @@ export function mapValues<T, P>(
   return result;
 }
 
+export function mapFilterValues<T, P>(
+  collection: { [key: string]: T },
+  iteratee: (item: T, key: string, collection: { [key: string]: T }) => P,
+  predicate: (item: T) => boolean
+): { [key: string]: P } {
+  const result = {};
+
+  Object.keys(collection).forEach(key => {
+    const item = collection[key];
+
+    if (!predicate(item)) {
+      return;
+    }
+
+    result[key] = iteratee(item, key, collection);
+  });
+
+  return result;
+}
+
 /**
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
  */
-export const path = (props: string[]): any => <T extends Record<string, any>>(
+export const path = <T extends Record<string, any>>(props: string[]): any => (
   object: T
 ): any => {
-  let result: Record<string, any> = object;
+  let result: T = object;
 
   for (const prop of props) {
-    result = result[prop];
+    result = result[prop as keyof typeof result];
   }
 
   return result;
 };
 
+/**
+ * Retrieves a value at the given path via the nested accessor prop.
+ * @param props The deep path to the prop of the desired value
+ */
+export function nestedPath<T extends Record<string, any>>(
+  props: string[],
+  accessorProp: keyof T
+): (object: T) => T {
+  return object => {
+    let result: T = object;
+
+    for (const prop of props) {
+      result = result[accessorProp][prop];
+    }
+
+    return result;
+  };
+}
+
 export const toStatePaths = (stateValue: StateValue): string[][] => {
   if (typeof stateValue === 'string') {
     return [[stateValue]];
   }
 
-  const result = Object.keys(stateValue)
-    .map(key => {
+  const result = flatMap(
+    Object.keys(stateValue).map(key => {
       return toStatePaths(stateValue[key]).map(subPath => {
         return [key].concat(subPath);
       });
     })
-    .reduce((a, b) => a.concat(b), []);
+  );
 
   return result;
 };
@@ -145,3 +186,7 @@ export const pathsToStateValue = (paths: string[][]): StateValue => {
 
   return result;
 };
+
+export const flatMap = <T>(array: T[][]): T[] => {
+  return array.reduce((a, b) => a.concat(b), []);
+};

package/test/actions.test.ts

@@ -311,7 +311,7 @@ describe('onEntry/onExit actions', () => {
         assert.isEmpty(pingPong.transition('ping.foo', 'TACK').actions);
       });
 
-      xit('with an absolute transition', () => {
+      it('with an absolute transition', () => {
         assert.isEmpty(
           pingPong.transition('ping.foo', 'ABSOLUTE_TACK').actions
         );
@@ -319,3 +319,26 @@ describe('onEntry/onExit actions', () => {
     });
   });
 });
+
+describe('actions on invalid transition', () => {
+  const stopMachine = Machine({
+    initial: 'idle',
+    states: {
+      idle: {
+        on: {
+          STOP: {
+            stop: {
+              actions: ['action1']
+            }
+          }
+        }
+      },
+      stop: {}
+    }
+  });
+
+  it('should not recall previous actions', () => {
+    const nextState = stopMachine.transition('idle', 'STOP');
+    assert.isEmpty(stopMachine.transition(nextState, 'INVALID').actions);
+  });
+});