xstate 3.2.1 → 3.3.3

package/lib/graph.d.ts

@@ -1,9 +1,12 @@
 import { StateNode } from './index';
 import { Machine, Edge, PathMap, PathItem, PathsItem, PathsMap, AdjacencyMap } from './types';
 export declare function getNodes(node: StateNode): StateNode[];
-export declare function getEdges(node: StateNode): Edge[];
-export declare function getAdjacencyMap(node: Machine): AdjacencyMap;
-export declare function getShortestPaths(machine: Machine): PathMap;
-export declare function getShortestPathsAsArray(machine: Machine): PathItem[];
-export declare function getSimplePaths(machine: Machine): PathsMap;
-export declare function getSimplePathsAsArray(machine: Machine): PathsItem[];
+export declare function getEventEdges(node: StateNode, event: string): Edge[];
+export declare function getEdges(node: StateNode, options?: {
+    deep: boolean;
+}): Edge[];
+export declare function getAdjacencyMap(node: Machine, extendedState?: any): AdjacencyMap;
+export declare function getShortestPaths(machine: Machine, extendedState?: any): PathMap;
+export declare function getShortestPathsAsArray(machine: Machine, extendedState?: any): PathItem[];
+export declare function getSimplePaths(machine: Machine, extendedState?: any): PathsMap;
+export declare function getSimplePathsAsArray(machine: Machine, extendedState?: any): PathsItem[];

package/lib/graph.js

@@ -15,19 +15,27 @@ function getNodes(node) {
 exports.getNodes = getNodes;
 function getEventEdges(node, event) {
     var transitions = node.on[event];
-    return transitions.map(function (transition) {
-        return {
-            source: node,
-            target: node.parent.getState(transition.target),
-            event: event,
-            actions: transition.actions ? transition.actions.map(utils_1.getActionType) : [],
-            cond: transition.cond
-        };
-    });
+    return utils_1.flatMap(transitions.map(function (transition) {
+        var targets = [].concat(transition.target);
+        return targets.map(function (target) {
+            var targetNode = node.getRelativeStateNodes(target, undefined, false)[0];
+            return {
+                source: node,
+                target: targetNode,
+                event: event,
+                actions: transition.actions
+                    ? transition.actions.map(utils_1.getActionType)
+                    : [],
+                cond: transition.cond
+            };
+        });
+    }));
 }
-function getEdges(node) {
+exports.getEventEdges = getEventEdges;
+function getEdges(node, options) {
+    var _a = (options || {}).deep, deep = _a === void 0 ? true : _a;
     var edges = [];
-    if (node.states) {
+    if (node.states && deep) {
         Object.keys(node.states).forEach(function (stateKey) {
             edges.push.apply(edges, getEdges(node.states[stateKey]));
         });
@@ -38,7 +46,7 @@ function getEdges(node) {
     return edges;
 }
 exports.getEdges = getEdges;
-function getAdjacencyMap(node) {
+function getAdjacencyMap(node, extendedState) {
     var adjacency = {};
     var events = node.events;
     function findAdjacencies(stateValue) {
@@ -49,7 +57,7 @@ function getAdjacencyMap(node) {
         adjacency[stateKey] = {};
         for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
             var event_1 = events_1[_i];
-            var nextState = node.transition(stateValue, event_1);
+            var nextState = node.transition(stateValue, event_1, extendedState);
             adjacency[stateKey][event_1] = { state: nextState.value };
             findAdjacencies(nextState.value);
         }
@@ -58,11 +66,12 @@ function getAdjacencyMap(node) {
     return adjacency;
 }
 exports.getAdjacencyMap = getAdjacencyMap;
-function getShortestPaths(machine) {
+function getShortestPaths(machine, extendedState) {
+    var _a;
     if (!machine.states) {
         return EMPTY_MAP;
     }
-    var adjacency = getAdjacencyMap(machine);
+    var adjacency = getAdjacencyMap(machine, extendedState);
     var initialStateId = JSON.stringify(machine.initialState.value);
     var pathMap = (_a = {},
         _a[initialStateId] = [],
@@ -102,22 +111,21 @@ function getShortestPaths(machine) {
     }
     util(machine.initialState.value);
     return pathMap;
-    var _a;
 }
 exports.getShortestPaths = getShortestPaths;
-function getShortestPathsAsArray(machine) {
-    var result = getShortestPaths(machine);
+function getShortestPathsAsArray(machine, extendedState) {
+    var result = getShortestPaths(machine, extendedState);
     return Object.keys(result).map(function (key) { return ({
         state: JSON.parse(key),
         path: result[key]
     }); });
 }
 exports.getShortestPathsAsArray = getShortestPathsAsArray;
-function getSimplePaths(machine) {
+function getSimplePaths(machine, extendedState) {
     if (!machine.states) {
         return EMPTY_MAP;
     }
-    var adjacency = getAdjacencyMap(machine);
+    var adjacency = getAdjacencyMap(machine, extendedState);
     var visited = new Set();
     var path = [];
     var paths = {};
@@ -151,8 +159,8 @@ function getSimplePaths(machine) {
     return paths;
 }
 exports.getSimplePaths = getSimplePaths;
-function getSimplePathsAsArray(machine) {
-    var result = getSimplePaths(machine);
+function getSimplePathsAsArray(machine, extendedState) {
+    var result = getSimplePaths(machine, extendedState);
     return Object.keys(result).map(function (key) { return ({
         state: JSON.parse(key),
         paths: result[key]

package/lib/patterns.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 function toggle(onState, offState, eventType) {
+    var _a, _b, _c;
     return _a = {},
         _a[onState] = {
             on: (_b = {}, _b[eventType] = offState, _b)
@@ -9,6 +10,5 @@ function toggle(onState, offState, eventType) {
             on: (_c = {}, _c[eventType] = onState, _c)
         },
         _a;
-    var _a, _b, _c;
 }
 exports.toggle = toggle;

package/lib/scxml.d.ts

@@ -1,7 +1,8 @@
 import { Machine, EventObject } from './types';
 export declare function fromMachine(machine: Machine): string;
 export interface ScxmlToMachineOptions {
-    evalCond: (expr: string) => ((extState: any, event: EventObject) => boolean) | Function;
+    evalCond: (expr: string) => // tslint:disable-next-line:ban-types
+    ((extState: any, event: EventObject) => boolean) | Function;
     delimiter?: string;
 }
 export declare function toMachine(xml: string, options: ScxmlToMachineOptions): any;

package/lib/scxml.js

@@ -75,10 +75,9 @@ function stateNodeToSCXML(stateNode) {
                     return {
                         type: 'element',
                         name: 'transition',
-                        attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getState(targetTransition.target)
-                                .id }, targetTransition.cond
+                        attributes: __assign({}, (event ? { event: event } : undefined), { target: stateNode.parent.getRelativeStateNodes(targetTransition.target)[0].id }, (targetTransition.cond
                             ? { cond: targetTransition.cond.toString() }
-                            : undefined),
+                            : undefined)),
                         elements: targetTransition.actions
                             ? targetTransition.actions.map(function (action) { return ({
                                 type: 'element',
@@ -96,9 +95,10 @@ function stateNodeToSCXML(stateNode) {
                 return {
                     type: 'element',
                     name: 'transition',
-                    attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getState(target).id }, targetTransition.cond
+                    attributes: __assign({}, (event ? { event: event } : undefined), { target: stateNode.parent.getRelativeStateNodes(target)[0]
+                            .id }, (targetTransition.cond
                         ? { cond: targetTransition.cond.toString() }
-                        : undefined),
+                        : undefined)),
                     elements: targetTransition.actions
                         ? targetTransition.actions.map(function (action) { return ({
                             type: 'element',
@@ -172,8 +172,31 @@ function toConfig(nodeJson, id, options) {
     var initial = parallel ? undefined : nodeJson.attributes.initial;
     var states;
     var on;
+    var elements = nodeJson.elements;
+    switch (nodeJson.name) {
+        case 'history': {
+            if (!elements) {
+                return {
+                    id: id,
+                    history: nodeJson.attributes.type || 'shallow'
+                };
+            }
+            var transitionElement = elements.filter(function (element) { return element.name === 'transition'; })[0];
+            return {
+                id: id,
+                history: nodeJson.attributes.type || 'shallow',
+                target: "#" + transitionElement.attributes.target
+            };
+        }
+        default:
+            break;
+    }
     if (nodeJson.elements) {
-        var stateElements = nodeJson.elements.filter(function (element) { return element.name === 'state' || element.name === 'parallel'; });
+        var stateElements = nodeJson.elements.filter(function (element) {
+            return element.name === 'state' ||
+                element.name === 'parallel' ||
+                element.name === 'history';
+        });
         var transitionElements = nodeJson.elements.filter(function (element) { return element.name === 'transition'; });
         var onEntryElement = nodeJson.elements.find(function (element) { return element.name === 'onentry'; });
         var onExitElement = nodeJson.elements.find(function (element) { return element.name === 'onexit'; });
@@ -185,11 +208,11 @@ function toConfig(nodeJson, id, options) {
         }
         states = indexedRecord(stateElements, function (item) { return "" + item.attributes.id; });
         on = utils_1.mapValues(indexedAggregateRecord(transitionElements, function (item) { return item.attributes.event || ''; }), function (values) {
-            return values.map(function (value) { return (__assign({ target: "#" + value.attributes.target }, value.elements ? executableContent(value.elements) : undefined, value.attributes.cond
+            return values.map(function (value) { return (__assign({ target: "#" + value.attributes.target }, (value.elements ? executableContent(value.elements) : undefined), (value.attributes.cond
                 ? {
                     cond: evalCond(value.attributes.cond)
                 }
-                : undefined)); });
+                : undefined))); });
         });
         var onEntry = onEntryElement
             ? onEntryElement.elements.map(function (element) {
@@ -211,13 +234,13 @@ function toConfig(nodeJson, id, options) {
                 }
             })
             : undefined;
-        return __assign({ id: id, delimiter: options.delimiter }, initial ? { initial: initial } : undefined, parallel ? { parallel: parallel } : undefined, stateElements.length
+        return __assign({ id: id, delimiter: options.delimiter }, (initial ? { initial: initial } : undefined), (parallel ? { parallel: parallel } : undefined), (stateElements.length
             ? {
                 states: utils_1.mapValues(states, function (state, key) {
                     return toConfig(state, key, options);
                 })
             }
-            : undefined, transitionElements.length ? { on: on } : undefined, onEntry ? { onEntry: onEntry } : undefined, onExit ? { onExit: onExit } : undefined);
+            : undefined), (transitionElements.length ? { on: on } : undefined), (onEntry ? { onEntry: onEntry } : undefined), (onExit ? { onExit: onExit } : undefined));
     }
     return { id: id };
 }

package/lib/types.d.ts

@@ -19,11 +19,17 @@ export interface StateValueMap {
     [key: string]: StateValue;
 }
 export declare type StateValue = string | StateValueMap;
-export declare type Condition = (extendedState: any, event?: EventObject) => boolean;
+export interface HistoryValue {
+    states: Record<string, HistoryValue | undefined>;
+    current: StateValue | undefined;
+}
+export declare type ConditionPredicate = (extendedState: any, event: EventObject, microstepState: StateValue) => boolean;
+export declare 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 {
     target: string | string[];
@@ -35,6 +41,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[];
@@ -51,15 +63,24 @@ export interface SimpleStateNodeConfig extends StateNodeConfig {
     parallel?: false | undefined;
     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 declare 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;
@@ -68,7 +89,6 @@ export interface StandardMachineConfig extends MachineConfig {
 export interface ParallelMachineConfig extends MachineConfig {
     initial?: undefined;
     parallel: true;
-    states: Record<string, CompoundStateNodeConfig>;
 }
 export interface EntryExitEffectMap {
     entry: Action[];
@@ -79,6 +99,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[];
@@ -88,6 +110,7 @@ export interface StateNode {
 }
 export interface ComplexStateNode extends StateNode {
     initial: string;
+    history: false;
 }
 export interface LeafStateNode extends StateNode {
     initial: never;
@@ -95,6 +118,10 @@ export interface LeafStateNode extends StateNode {
     states: never;
     parent: StateNode;
 }
+export interface HistoryStateNode extends StateNode {
+    history: 'shallow' | 'deep';
+    target: StateValue | undefined;
+}
 export interface Machine extends StateNode {
     id: string;
     initial: string | undefined;
@@ -116,15 +143,19 @@ export interface ActionMap {
     actions: Action[];
     onExit: Action[];
 }
+export interface EntryExitStates {
+    entry: Set<StateNode>;
+    exit: Set<StateNode>;
+}
 export interface ActivityMap {
     [activityKey: string]: boolean;
 }
 export declare type MaybeStateValueActionsTuple = [StateValue | undefined, ActionMap, ActivityMap | undefined];
 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 {
     value: StateValue | undefined;

package/lib/utils.d.ts

@@ -12,10 +12,23 @@ export declare function mapValues<T, P>(collection: {
 }) => P): {
     [key: string]: P;
 };
+export declare 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;
+};
 /**
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
  */
-export declare const path: (props: string[]) => any;
+export declare const path: <T extends Record<string, any>>(props: string[]) => any;
+/**
+ * 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 declare function nestedPath<T extends Record<string, any>>(props: string[], accessorProp: keyof T): (object: T) => T;
 export declare const toStatePaths: (stateValue: StateValue) => string[][];
 export declare const pathsToStateValue: (paths: string[][]) => StateValue;
+export declare const flatMap: <T>(array: T[][]) => T[];

package/lib/utils.js

@@ -16,7 +16,9 @@ function getActionType(action) {
     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.');
@@ -72,6 +74,18 @@ function mapValues(collection, iteratee) {
     return result;
 }
 exports.mapValues = mapValues;
+function mapFilterValues(collection, iteratee, predicate) {
+    var result = {};
+    Object.keys(collection).forEach(function (key) {
+        var item = collection[key];
+        if (!predicate(item)) {
+            return;
+        }
+        result[key] = iteratee(item, key, collection);
+    });
+    return result;
+}
+exports.mapFilterValues = mapFilterValues;
 /**
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
@@ -84,17 +98,30 @@ exports.path = function (props) { return function (object) {
     }
     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
+ */
+function nestedPath(props, accessorProp) {
+    return function (object) {
+        var result = object;
+        for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+            var prop = props_2[_i];
+            result = result[accessorProp][prop];
+        }
+        return result;
+    };
+}
+exports.nestedPath = nestedPath;
 exports.toStatePaths = function (stateValue) {
     if (typeof stateValue === 'string') {
         return [[stateValue]];
     }
-    var result = Object.keys(stateValue)
-        .map(function (key) {
+    var result = exports.flatMap(Object.keys(stateValue).map(function (key) {
         return exports.toStatePaths(stateValue[key]).map(function (subPath) {
             return [key].concat(subPath);
         });
-    })
-        .reduce(function (a, b) { return a.concat(b); }, []);
+    }));
     return result;
 };
 exports.pathsToStateValue = function (paths) {
@@ -118,3 +145,6 @@ exports.pathsToStateValue = function (paths) {
     }
     return result;
 };
+exports.flatMap = function (array) {
+    return array.reduce(function (a, b) { return a.concat(b); }, []);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "3.2.1",
+  "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.7.1",
+    "typescript": "^2.9.2",
     "webpack": "^3.5.6",
     "xml-js": "^1.6.2"
   },

package/src/Machine.ts

@@ -3,12 +3,14 @@ import {
   StandardMachine,
   ParallelMachine,
   MachineConfig,
-  ParallelMachineConfig
+  ParallelMachineConfig,
+  MachineOptions
 } from './types';
 import { StateNode } from './StateNode';
 
 export function Machine(
-  config: MachineConfig | ParallelMachineConfig
+  config: MachineConfig | ParallelMachineConfig,
+  options?: MachineOptions
 ): StandardMachine | ParallelMachine {
-  return new StateNode(config) as StandardMachine | ParallelMachine;
+  return new StateNode(config, options) as StandardMachine | ParallelMachine;
 }

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';
 
@@ -20,7 +21,13 @@ export class State implements StateInterface {
       if (!stateValue.actions.length) {
         return stateValue;
       }
-      return new State(stateValue.value, stateValue.history, []);
+      return new State(
+        stateValue.value,
+        stateValue.historyValue,
+        stateValue.history,
+        [],
+        stateValue.activities
+      );
     }
 
     return State.from(stateValue);
@@ -28,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,