xstate 3.3.2 → 3.3.3

package/lib/StateNode.d.ts

@@ -1,6 +1,6 @@
-import { Event, StateValue, Action, StandardMachine, ParallelMachine, SimpleOrCompoundStateNodeConfig, MachineConfig, ParallelMachineConfig, EventType, StandardMachineConfig, Activity, ConditionalTransitionConfig, EntryExitStates, _StateTransition, StateValueMap, MachineOptions } from './types';
+import { Event, StateValue, Action, StandardMachine, ParallelMachine, SimpleOrCompoundStateNodeConfig, ParallelMachineConfig, EventType, StandardMachineConfig, Activity, ConditionalTransitionConfig, StateTransition, MachineOptions, HistoryValue } from './types';
 import { State } from './State';
-declare class StateNode implements StateNode {
+declare class StateNode {
     config: SimpleOrCompoundStateNodeConfig | StandardMachineConfig | ParallelMachineConfig;
     options: MachineOptions;
     key: string;
@@ -25,22 +25,23 @@ declare class StateNode implements StateNode {
     constructor(config: SimpleOrCompoundStateNodeConfig | StandardMachineConfig | ParallelMachineConfig, options?: MachineOptions);
     getStateNodes(state: StateValue | State): StateNode[];
     handles(event: Event): boolean;
-    _transitionLeafNode(stateValue: string, state: State, event: Event, extendedState?: any): _StateTransition;
-    _transitionHierarchicalNode(stateValue: StateValueMap, state: State, event: Event, extendedState?: any): _StateTransition;
-    _transitionOrthogonalNode(stateValue: StateValueMap, state: State, event: Event, extendedState?: any): _StateTransition;
-    _transition(stateValue: StateValue, state: State, event: Event, extendedState?: any): _StateTransition;
-    _next(state: State, event: Event, extendedState?: any): _StateTransition;
-    _getEntryExitStates(nextStateNode: StateNode, internal: boolean): EntryExitStates;
-    private _evaluateCond(condition, extendedState, eventObject, interimState);
-    private _getActions(transition);
-    private _getActivities(state, transition);
+    private _transitionLeafNode;
+    private _transitionHierarchicalNode;
+    private _transitionOrthogonalNode;
+    _transition(stateValue: StateValue, state: State, event: Event, extendedState?: any): StateTransition;
+    private _next;
+    private _getEntryExitStates;
+    private _evaluateCond;
+    private _getActions;
+    private _getActivities;
     transition(state: StateValue | State, event: Event, extendedState?: any): State;
-    private ensureValidPaths(paths);
+    private ensureValidPaths;
     getStateNode(stateKey: string): StateNode;
     getStateNodeById(stateId: string): StateNode;
-    private resolve(stateValue);
+    getStateNodeByPath(statePath: string | string[]): StateNode;
+    private resolve;
     private readonly resolvedStateValue;
-    private getResolvedPath(stateIdentifier);
+    private getResolvedPath;
     private readonly initialStateValue;
     readonly initialState: State;
     readonly target: StateValue | undefined;
@@ -52,13 +53,27 @@ declare class StateNode implements StateNode {
      * @param history The previous state to retrieve history
      * @param resolve Whether state nodes should resolve to initial child state nodes
      */
-    getRelativeStateNodes(relativeStateId: string | string[], history?: State, resolve?: boolean): StateNode[];
+    getRelativeStateNodes(relativeStateId: string | string[], historyValue?: HistoryValue, resolve?: boolean): StateNode[];
     readonly initialStateNodes: StateNode[];
-    getFromRelativePath(relativePath: string[], historyValue?: StateValue): StateNode[];
-    private resolveHistory(historyValue?);
+    /**
+     * Retrieves state nodes from a relative path to this state node.
+     *
+     * @param relativePath The relative path from this state node
+     * @param historyValue
+     */
+    getFromRelativePath(relativePath: string[], historyValue?: HistoryValue): StateNode[];
+    static updateHistoryValue(hist: HistoryValue, stateValue: StateValue): HistoryValue;
+    historyValue(relativeStateValue?: StateValue | undefined): HistoryValue | undefined;
+    /**
+     * Resolves to the historical value(s) of the parent state node,
+     * represented by state nodes.
+     *
+     * @param historyValue
+     */
+    private resolveHistory;
     readonly events: EventType[];
-    private formatTransition(targets, transitionConfig?);
-    private formatTransitions(onConfig);
+    private formatTransition;
+    private formatTransitions;
 }
-export declare function Machine(config: MachineConfig | ParallelMachineConfig, options: MachineOptions): StandardMachine | ParallelMachine;
+export declare function Machine<T extends StandardMachineConfig | ParallelMachineConfig>(config: T, options?: MachineOptions): T extends ParallelMachineConfig ? ParallelMachine : T extends StandardMachineConfig ? StandardMachine : never;
 export { StateNode };

package/lib/StateNode.js

@@ -17,11 +17,6 @@ var HISTORY_KEY = '$history';
 var NULL_EVENT = '';
 var STATE_IDENTIFIER = '#';
 var isStateId = function (str) { return str[0] === STATE_IDENTIFIER; };
-// const emptyActions: ActionMap = Object.freeze({
-//   onEntry: [],
-//   onExit: [],
-//   actions: []
-// });
 var defaultOptions = {
     guards: {}
 };
@@ -53,10 +48,10 @@ var StateNode = /** @class */ (function () {
         this.parallel = !!config.parallel;
         this.states = (config.states
             ? utils_1.mapValues(config.states, function (stateConfig, key) {
+                var _a;
                 var stateNode = new StateNode(__assign({}, stateConfig, { key: key, parent: _this }));
                 Object.assign(_this.idMap, __assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
                 return stateNode;
-                var _a;
             })
             : {});
         // History config
@@ -74,6 +69,7 @@ var StateNode = /** @class */ (function () {
     }
     StateNode.prototype.getStateNodes = function (state) {
         var _this = this;
+        var _a;
         if (!state) {
             return [];
         }
@@ -94,7 +90,6 @@ var StateNode = /** @class */ (function () {
             var subStateNode = _this.getStateNode(subStateKey).getStateNodes(stateValue[subStateKey]);
             return allSubStateNodes.concat(subStateNode);
         }, []));
-        var _a;
     };
     StateNode.prototype.handles = function (event) {
         var eventType = utils_1.getEventType(event);
@@ -196,10 +191,10 @@ var StateNode = /** @class */ (function () {
         }
         var allResolvedPaths = utils_1.flatMap(Object.keys(transitionMap).map(function (key) {
             var transition = transitionMap[key];
-            if (!transition.value) {
-                return utils_1.toStatePaths(utils_1.path(_this.path)(state.value)[key]).map(function (statePath) { return _this.path.concat(key, statePath); });
-            }
-            return transition.paths;
+            var value = transition.value || state.value;
+            return utils_1.toStatePaths(utils_1.path(_this.path)(value)[key]).map(function (statePath) {
+                return _this.path.concat(key, statePath);
+            });
         }));
         var nextStateValue = this.machine.resolve(utils_1.pathsToStateValue(allResolvedPaths));
         return {
@@ -282,7 +277,7 @@ var StateNode = /** @class */ (function () {
             };
         }
         var nextStateNodes = utils_1.flatMap(nextStateStrings.map(function (str) {
-            return _this.getRelativeStateNodes(str, state.history);
+            return _this.getRelativeStateNodes(str, state.historyValue);
         }));
         var nextStatePaths = nextStateNodes.map(function (stateNode) { return stateNode.path; });
         var entryExitStates = nextStateNodes.reduce(function (allEntryExitStates, nextStateNode) {
@@ -294,7 +289,7 @@ var StateNode = /** @class */ (function () {
         }, { entry: new Set(), exit: new Set() });
         return {
             value: this.machine.resolve(utils_1.pathsToStateValue(utils_1.flatMap(nextStateStrings.map(function (str) {
-                return _this.getRelativeStateNodes(str, state.history).map(function (s) { return s.path; });
+                return _this.getRelativeStateNodes(str, state.historyValue).map(function (s) { return s.path; });
             })))),
             entryExitStates: entryExitStates,
             actions: actions,
@@ -348,8 +343,7 @@ var StateNode = /** @class */ (function () {
         var condFn;
         if (typeof condition === 'string') {
             if (!this.machine.options.guards[condition]) {
-                throw new Error("String condition '" + condition + "' is not defined on machine '" + this
-                    .machine.id + "'");
+                throw new Error("String condition '" + condition + "' is not defined on machine '" + this.machine.id + "'");
             }
             condFn = this.machine.options.guards[condition];
         }
@@ -381,28 +375,31 @@ var StateNode = /** @class */ (function () {
             return {};
         }
         var activityMap = __assign({}, state.activities);
-        Array.from(transition.entryExitStates.entry).forEach(function (stateNode) {
+        Array.from(transition.entryExitStates.exit).forEach(function (stateNode) {
             if (!stateNode.activities) {
                 return; // TODO: fixme
             }
             stateNode.activities.forEach(function (activity) {
-                activityMap[utils_1.getActionType(activity)] = true;
+                activityMap[utils_1.getActionType(activity)] = false;
             });
         });
-        Array.from(transition.entryExitStates.exit).forEach(function (stateNode) {
+        Array.from(transition.entryExitStates.entry).forEach(function (stateNode) {
             if (!stateNode.activities) {
                 return; // TODO: fixme
             }
             stateNode.activities.forEach(function (activity) {
-                activityMap[utils_1.getActionType(activity)] = false;
+                activityMap[utils_1.getActionType(activity)] = true;
             });
         });
         return activityMap;
     };
     StateNode.prototype.transition = function (state, event, extendedState) {
+        var _a;
         var resolvedStateValue = typeof state === 'string'
             ? this.resolve(utils_1.pathToStateValue(this.getResolvedPath(state)))
-            : state instanceof State_1.State ? state : this.resolve(state);
+            : state instanceof State_1.State
+                ? state
+                : this.resolve(state);
         var eventType = utils_1.getEventType(event);
         if (this.strict) {
             if (this.events.indexOf(eventType) === -1) {
@@ -410,6 +407,11 @@ var StateNode = /** @class */ (function () {
             }
         }
         var currentState = State_1.State.from(resolvedStateValue);
+        var historyValue = resolvedStateValue instanceof State_1.State
+            ? resolvedStateValue.historyValue
+                ? resolvedStateValue.historyValue
+                : this.machine.historyValue(resolvedStateValue.value)
+            : this.machine.historyValue(resolvedStateValue);
         var stateTransition = this._transition(currentState.value, currentState, event, extendedState);
         try {
             this.ensureValidPaths(stateTransition.paths);
@@ -438,15 +440,15 @@ var StateNode = /** @class */ (function () {
         stateNodes.forEach(function (stateNode) {
             data[stateNode.id] = stateNode.data;
         });
-        // Dispose of previous histories to prevent memory leaks
-        delete currentState.history;
         var nextState = stateTransition.value
-            ? new State_1.State(stateTransition.value, currentState, nonEventActions, activities, data, raisedEvents)
+            ? new State_1.State(stateTransition.value, StateNode.updateHistoryValue(historyValue, stateTransition.value), currentState, nonEventActions, activities, data, raisedEvents)
             : undefined;
         if (!nextState) {
             // Unchanged state should be returned with no actions
             return State_1.State.inert(currentState);
         }
+        // Dispose of previous histories to prevent memory leaks
+        delete currentState.history;
         var maybeNextState = nextState;
         while (raisedEvents.length) {
             var currentActions = maybeNextState.actions;
@@ -455,7 +457,6 @@ var StateNode = /** @class */ (function () {
             (_a = maybeNextState.actions).unshift.apply(_a, currentActions);
         }
         return maybeNextState;
-        var _a;
     };
     StateNode.prototype.ensureValidPaths = function (paths) {
         var _this = this;
@@ -469,8 +470,9 @@ var StateNode = /** @class */ (function () {
                     if (marker.parent.parallel) {
                         continue outer;
                     }
-                    throw new Error("State node '" + stateNode.id + "' shares parent '" + marker.parent
-                        .id + "' with state node '" + visitedParents.get(marker.parent).map(function (a) { return a.id; }) + "'");
+                    throw new Error("State node '" + stateNode.id + "' shares parent '" + marker.parent.id + "' with state node '" + visitedParents
+                        .get(marker.parent)
+                        .map(function (a) { return a.id; }) + "'");
                 }
                 if (!visitedParents.get(marker.parent)) {
                     visitedParents.set(marker.parent, [stateNode]);
@@ -487,8 +489,7 @@ var StateNode = /** @class */ (function () {
             return this.machine.getStateNodeById(stateKey);
         }
         if (!this.states) {
-            throw new Error("Unable to retrieve child state '" + stateKey + "' from '" + this
-                .id + "'; no child states exist.");
+            throw new Error("Unable to retrieve child state '" + stateKey + "' from '" + this.id + "'; no child states exist.");
         }
         var result = this.states[stateKey];
         if (!result) {
@@ -506,8 +507,18 @@ var StateNode = /** @class */ (function () {
         }
         return stateNode;
     };
+    StateNode.prototype.getStateNodeByPath = function (statePath) {
+        var arrayStatePath = utils_1.toStatePath(statePath, this.delimiter);
+        var currentStateNode = this;
+        while (arrayStatePath.length) {
+            var key = arrayStatePath.shift();
+            currentStateNode = currentStateNode.getStateNode(key);
+        }
+        return currentStateNode;
+    };
     StateNode.prototype.resolve = function (stateValue) {
         var _this = this;
+        var _a;
         if (typeof stateValue === 'string') {
             var subStateNode = this.getStateNode(stateValue);
             return subStateNode.initial
@@ -525,10 +536,10 @@ var StateNode = /** @class */ (function () {
                 ? _this.getStateNode(subStateKey).resolve(subStateValue)
                 : {};
         });
-        var _a;
     };
     Object.defineProperty(StateNode.prototype, "resolvedStateValue", {
         get: function () {
+            var _a, _b;
             var key = this.key;
             if (this.parallel) {
                 return _a = {},
@@ -542,7 +553,6 @@ var StateNode = /** @class */ (function () {
             return _b = {},
                 _b[key] = this.states[this.initial].resolvedStateValue,
                 _b;
-            var _a, _b;
         },
         enumerable: true,
         configurable: true
@@ -575,6 +585,7 @@ var StateNode = /** @class */ (function () {
     });
     Object.defineProperty(StateNode.prototype, "initialState", {
         get: function () {
+            var _a;
             var initialStateValue = this.initialStateValue;
             if (!initialStateValue) {
                 throw new Error("Cannot retrieve initial state from simple state '" + this.id + ".'");
@@ -592,7 +603,21 @@ var StateNode = /** @class */ (function () {
                     });
                 }
             });
-            return new State_1.State(initialStateValue, undefined, actions, activityMap);
+            // TODO: deduplicate - DRY (from this.transition())
+            var raisedEvents = actions.filter(function (action) {
+                return typeof action === 'object' &&
+                    (action.type === actions_1.actionTypes.raise || action.type === actions_1.actionTypes.null);
+            });
+            var initialState = new State_1.State(initialStateValue, undefined, undefined, actions, activityMap);
+            var maybeNextState = initialState;
+            while (raisedEvents.length) {
+                var currentActions = maybeNextState.actions;
+                var raisedEvent = raisedEvents.shift();
+                maybeNextState = this.transition(maybeNextState, raisedEvent.type === actions_1.actionTypes.null ? NULL_EVENT : raisedEvent.event, undefined // TODO: consider initial state given external state
+                );
+                (_a = maybeNextState.actions).unshift.apply(_a, currentActions);
+            }
+            return maybeNextState;
         },
         enumerable: true,
         configurable: true
@@ -636,9 +661,8 @@ var StateNode = /** @class */ (function () {
      * @param history The previous state to retrieve history
      * @param resolve Whether state nodes should resolve to initial child state nodes
      */
-    StateNode.prototype.getRelativeStateNodes = function (relativeStateId, history, resolve) {
+    StateNode.prototype.getRelativeStateNodes = function (relativeStateId, historyValue, resolve) {
         if (resolve === void 0) { resolve = true; }
-        var historyValue = history ? history.value : undefined;
         if (typeof relativeStateId === 'string' && isStateId(relativeStateId)) {
             var unresolvedStateNode = this.getStateNodeById(relativeStateId);
             return resolve
@@ -671,6 +695,12 @@ var StateNode = /** @class */ (function () {
         enumerable: true,
         configurable: true
     });
+    /**
+     * Retrieves state nodes from a relative path to this state node.
+     *
+     * @param relativePath The relative path from this state node
+     * @param historyValue
+     */
     StateNode.prototype.getFromRelativePath = function (relativePath, historyValue) {
         var _this = this;
         if (!relativePath.length) {
@@ -685,7 +715,7 @@ var StateNode = /** @class */ (function () {
             if (!historyValue) {
                 return [this];
             }
-            var subHistoryValue = utils_1.path(this.path)(historyValue);
+            var subHistoryValue = utils_1.nestedPath(this.path, 'states')(historyValue).current;
             if (typeof subHistoryValue === 'string') {
                 return this.states[subHistoryValue].getFromRelativePath(xs, historyValue);
             }
@@ -702,6 +732,51 @@ var StateNode = /** @class */ (function () {
         }
         return this.states[x].getFromRelativePath(xs, historyValue);
     };
+    StateNode.updateHistoryValue = function (hist, stateValue) {
+        function update(_hist, _sv) {
+            return utils_1.mapValues(_hist.states, function (subHist, key) {
+                if (!subHist) {
+                    return undefined;
+                }
+                var 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)
+        };
+    };
+    StateNode.prototype.historyValue = function (relativeStateValue) {
+        if (!Object.keys(this.states).length) {
+            return undefined;
+        }
+        return {
+            current: relativeStateValue || this.initialStateValue,
+            states: utils_1.mapFilterValues(this.states, function (stateNode, key) {
+                if (!relativeStateValue) {
+                    return stateNode.historyValue();
+                }
+                var subStateValue = typeof relativeStateValue === 'string'
+                    ? undefined
+                    : relativeStateValue[key];
+                return stateNode.historyValue(subStateValue || stateNode.initialStateValue);
+            }, function (stateNode) { return !stateNode.history; })
+        };
+    };
+    /**
+     * Resolves to the historical value(s) of the parent state node,
+     * represented by state nodes.
+     *
+     * @param historyValue
+     */
     StateNode.prototype.resolveHistory = function (historyValue) {
         var _this = this;
         if (!this.history) {
@@ -711,21 +786,19 @@ var StateNode = /** @class */ (function () {
         if (!historyValue) {
             return this.target
                 ? utils_1.flatMap(utils_1.toStatePaths(this.target).map(function (relativeChildPath) {
-                    return parent.getFromRelativePath(relativeChildPath, historyValue);
+                    return parent.getFromRelativePath(relativeChildPath);
                 }))
                 : this.parent.initialStateNodes;
         }
-        else {
-            var subHistoryValue = utils_1.path(parent.path)(historyValue);
-            if (typeof subHistoryValue === 'string') {
-                return [parent.getStateNode(subHistoryValue)];
-            }
-            return utils_1.flatMap(utils_1.toStatePaths(subHistoryValue).map(function (subStatePath) {
-                return _this.history === 'deep'
-                    ? parent.getFromRelativePath(subStatePath)
-                    : [parent.states[subStatePath[0]]];
-            }));
+        var subHistoryValue = utils_1.nestedPath(parent.path, 'states')(historyValue).current;
+        if (typeof subHistoryValue === 'string') {
+            return [parent.getStateNode(subHistoryValue)];
         }
+        return utils_1.flatMap(utils_1.toStatePaths(subHistoryValue).map(function (subStatePath) {
+            return _this.history === 'deep'
+                ? parent.getFromRelativePath(subStatePath)
+                : [parent.states[subStatePath[0]]];
+        }));
     };
     Object.defineProperty(StateNode.prototype, "events", {
         get: function () {

package/lib/graph.d.ts

@@ -1,7 +1,10 @@
 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 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[];

package/lib/graph.js

@@ -31,9 +31,11 @@ function getEventEdges(node, event) {
         });
     }));
 }
-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]));
         });
@@ -65,6 +67,7 @@ function getAdjacencyMap(node, extendedState) {
 }
 exports.getAdjacencyMap = getAdjacencyMap;
 function getShortestPaths(machine, extendedState) {
+    var _a;
     if (!machine.states) {
         return EMPTY_MAP;
     }
@@ -108,7 +111,6 @@ function getShortestPaths(machine, extendedState) {
     }
     util(machine.initialState.value);
     return pathMap;
-    var _a;
 }
 exports.getShortestPaths = getShortestPaths;
 function getShortestPathsAsArray(machine, extendedState) {

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,9 +75,9 @@ function stateNodeToSCXML(stateNode) {
                     return {
                         type: 'element',
                         name: 'transition',
-                        attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getRelativeStateNodes(targetTransition.target)[0].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',
@@ -95,9 +95,10 @@ function stateNodeToSCXML(stateNode) {
                 return {
                     type: 'element',
                     name: 'transition',
-                    attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getRelativeStateNodes(target)[0].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',
@@ -207,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) {
@@ -233,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,6 +19,10 @@ export interface StateValueMap {
     [key: string]: StateValue;
 }
 export declare type StateValue = string | StateValueMap;
+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 {
@@ -85,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[];
@@ -149,12 +152,6 @@ export interface ActivityMap {
 }
 export declare type MaybeStateValueActionsTuple = [StateValue | undefined, ActionMap, ActivityMap | undefined];
 export interface StateTransition {
-    statePaths: string[][];
-    actions: ActionMap;
-    activities: ActivityMap | undefined;
-    events: EventObject[];
-}
-export interface _StateTransition {
     value: StateValue | undefined;
     entryExitStates: EntryExitStates | undefined;
     actions: Action[];

package/lib/utils.d.ts

@@ -23,7 +23,12 @@ export declare function mapFilterValues<T, P>(collection: {
  * 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.');
@@ -96,6 +98,21 @@ 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]];