xstate 3.3.2 → 3.3.3

package/es/StateNode.js

@@ -6,7 +6,7 @@ var __assign = (this && this.__assign) || Object.assign || function(t) {
     }
     return t;
 };
-import { getEventType, toStatePath, toStateValue, mapValues, path, toStatePaths, pathsToStateValue, pathToStateValue, getActionType, flatMap, mapFilterValues } from './utils';
+import { getEventType, toStatePath, toStateValue, mapValues, path, toStatePaths, pathsToStateValue, pathToStateValue, getActionType, flatMap, mapFilterValues, nestedPath } from './utils';
 import { matchesState } from './matchesState';
 import { State } from './State';
 import { start, stop, toEventObject, actionTypes } from './actions';
@@ -15,11 +15,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: {}
 };
@@ -51,10 +46,10 @@ var StateNode = /** @class */ (function () {
         this.parallel = !!config.parallel;
         this.states = (config.states
             ? 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
@@ -72,6 +67,7 @@ var StateNode = /** @class */ (function () {
     }
     StateNode.prototype.getStateNodes = function (state) {
         var _this = this;
+        var _a;
         if (!state) {
             return [];
         }
@@ -92,7 +88,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 = getEventType(event);
@@ -194,10 +189,10 @@ var StateNode = /** @class */ (function () {
         }
         var allResolvedPaths = flatMap(Object.keys(transitionMap).map(function (key) {
             var transition = transitionMap[key];
-            if (!transition.value) {
-                return toStatePaths(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 toStatePaths(path(_this.path)(value)[key]).map(function (statePath) {
+                return _this.path.concat(key, statePath);
+            });
         }));
         var nextStateValue = this.machine.resolve(pathsToStateValue(allResolvedPaths));
         return {
@@ -280,7 +275,7 @@ var StateNode = /** @class */ (function () {
             };
         }
         var nextStateNodes = 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) {
@@ -292,7 +287,7 @@ var StateNode = /** @class */ (function () {
         }, { entry: new Set(), exit: new Set() });
         return {
             value: this.machine.resolve(pathsToStateValue(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,
@@ -346,8 +341,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];
         }
@@ -379,28 +373,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[getActionType(activity)] = true;
+                activityMap[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[getActionType(activity)] = false;
+                activityMap[getActionType(activity)] = true;
             });
         });
         return activityMap;
     };
     StateNode.prototype.transition = function (state, event, extendedState) {
+        var _a;
         var resolvedStateValue = typeof state === 'string'
             ? this.resolve(pathToStateValue(this.getResolvedPath(state)))
-            : state instanceof State ? state : this.resolve(state);
+            : state instanceof State
+                ? state
+                : this.resolve(state);
         var eventType = getEventType(event);
         if (this.strict) {
             if (this.events.indexOf(eventType) === -1) {
@@ -408,6 +405,11 @@ var StateNode = /** @class */ (function () {
             }
         }
         var currentState = State.from(resolvedStateValue);
+        var historyValue = resolvedStateValue instanceof 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);
@@ -436,15 +438,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(stateTransition.value, currentState, nonEventActions, activities, data, raisedEvents)
+            ? new 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.inert(currentState);
         }
+        // Dispose of previous histories to prevent memory leaks
+        delete currentState.history;
         var maybeNextState = nextState;
         while (raisedEvents.length) {
             var currentActions = maybeNextState.actions;
@@ -453,7 +455,6 @@ var StateNode = /** @class */ (function () {
             (_a = maybeNextState.actions).unshift.apply(_a, currentActions);
         }
         return maybeNextState;
-        var _a;
     };
     StateNode.prototype.ensureValidPaths = function (paths) {
         var _this = this;
@@ -467,8 +468,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]);
@@ -485,8 +487,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) {
@@ -504,8 +505,18 @@ var StateNode = /** @class */ (function () {
         }
         return stateNode;
     };
+    StateNode.prototype.getStateNodeByPath = function (statePath) {
+        var arrayStatePath = 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
@@ -523,10 +534,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 = {},
@@ -540,7 +551,6 @@ var StateNode = /** @class */ (function () {
             return _b = {},
                 _b[key] = this.states[this.initial].resolvedStateValue,
                 _b;
-            var _a, _b;
         },
         enumerable: true,
         configurable: true
@@ -573,6 +583,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 + ".'");
@@ -590,7 +601,21 @@ var StateNode = /** @class */ (function () {
                     });
                 }
             });
-            return new State(initialStateValue, undefined, actions, activityMap);
+            // TODO: deduplicate - DRY (from this.transition())
+            var raisedEvents = actions.filter(function (action) {
+                return typeof action === 'object' &&
+                    (action.type === actionTypes.raise || action.type === actionTypes.null);
+            });
+            var initialState = new 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 === 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
@@ -634,9 +659,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
@@ -669,6 +693,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) {
@@ -683,7 +713,7 @@ var StateNode = /** @class */ (function () {
             if (!historyValue) {
                 return [this];
             }
-            var subHistoryValue = path(this.path)(historyValue);
+            var subHistoryValue = nestedPath(this.path, 'states')(historyValue).current;
             if (typeof subHistoryValue === 'string') {
                 return this.states[subHistoryValue].getFromRelativePath(xs, historyValue);
             }
@@ -700,6 +730,51 @@ var StateNode = /** @class */ (function () {
         }
         return this.states[x].getFromRelativePath(xs, historyValue);
     };
+    StateNode.updateHistoryValue = function (hist, stateValue) {
+        function update(_hist, _sv) {
+            return 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: 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) {
@@ -709,21 +784,19 @@ var StateNode = /** @class */ (function () {
         if (!historyValue) {
             return this.target
                 ? flatMap(toStatePaths(this.target).map(function (relativeChildPath) {
-                    return parent.getFromRelativePath(relativeChildPath, historyValue);
+                    return parent.getFromRelativePath(relativeChildPath);
                 }))
                 : this.parent.initialStateNodes;
         }
-        else {
-            var subHistoryValue = path(parent.path)(historyValue);
-            if (typeof subHistoryValue === 'string') {
-                return [parent.getStateNode(subHistoryValue)];
-            }
-            return flatMap(toStatePaths(subHistoryValue).map(function (subStatePath) {
-                return _this.history === 'deep'
-                    ? parent.getFromRelativePath(subStatePath)
-                    : [parent.states[subStatePath[0]]];
-            }));
+        var subHistoryValue = nestedPath(parent.path, 'states')(historyValue).current;
+        if (typeof subHistoryValue === 'string') {
+            return [parent.getStateNode(subHistoryValue)];
         }
+        return flatMap(toStatePaths(subHistoryValue).map(function (subStatePath) {
+            return _this.history === 'deep'
+                ? parent.getFromRelativePath(subStatePath)
+                : [parent.states[subStatePath[0]]];
+        }));
     };
     Object.defineProperty(StateNode.prototype, "events", {
         get: function () {

package/es/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/es/graph.js

@@ -10,7 +10,7 @@ export function getNodes(node) {
     }, []);
     return nodes;
 }
-function getEventEdges(node, event) {
+export function getEventEdges(node, event) {
     var transitions = node.on[event];
     return flatMap(transitions.map(function (transition) {
         var targets = [].concat(transition.target);
@@ -28,9 +28,10 @@ function getEventEdges(node, event) {
         });
     }));
 }
-export function getEdges(node) {
+export 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]));
         });
@@ -60,6 +61,7 @@ export function getAdjacencyMap(node, extendedState) {
     return adjacency;
 }
 export function getShortestPaths(machine, extendedState) {
+    var _a;
     if (!machine.states) {
         return EMPTY_MAP;
     }
@@ -103,7 +105,6 @@ export function getShortestPaths(machine, extendedState) {
     }
     util(machine.initialState.value);
     return pathMap;
-    var _a;
 }
 export function getShortestPathsAsArray(machine, extendedState) {
     var result = getShortestPaths(machine, extendedState);

package/es/patterns.js

@@ -1,4 +1,5 @@
 export function toggle(onState, offState, eventType) {
+    var _a, _b, _c;
     return _a = {},
         _a[onState] = {
             on: (_b = {}, _b[eventType] = offState, _b)
@@ -7,5 +8,4 @@ export function toggle(onState, offState, eventType) {
             on: (_c = {}, _c[eventType] = onState, _c)
         },
         _a;
-    var _a, _b, _c;
 }

package/es/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/es/scxml.js

@@ -73,9 +73,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',
@@ -93,9 +93,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',
@@ -204,11 +205,11 @@ function toConfig(nodeJson, id, options) {
         }
         states = indexedRecord(stateElements, function (item) { return "" + item.attributes.id; });
         on = 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) {
@@ -230,13 +231,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: 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/es/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/es/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/es/utils.js

@@ -13,7 +13,9 @@ export 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.');
@@ -87,6 +89,20 @@ export var 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
+ */
+export 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;
+    };
+}
 export var toStatePaths = function (stateValue) {
     if (typeof stateValue === 'string') {
         return [[stateValue]];

package/lib/State.d.ts

@@ -1,7 +1,8 @@
-import { StateValue, ActivityMap, EventObject, Action, StateInterface } from './types';
+import { StateValue, ActivityMap, EventObject, Action, StateInterface, HistoryValue } from './types';
 export declare class State implements StateInterface {
     value: StateValue;
-    history: State | undefined;
+    historyValue?: HistoryValue | undefined;
+    history?: State | undefined;
     actions: Action[];
     activities: ActivityMap;
     data: Record<string, any>;
@@ -11,10 +12,10 @@ export declare class State implements StateInterface {
     events: EventObject[];
     static from(stateValue: State | StateValue): State;
     static inert(stateValue: State | StateValue): State;
-    constructor(value: StateValue, history?: State | undefined, actions?: Action[], activities?: ActivityMap, data?: Record<string, any>, 
-        /**
-         * Internal event queue
-         */
-        events?: EventObject[]);
+    constructor(value: StateValue, historyValue?: HistoryValue | undefined, history?: State | undefined, actions?: Action[], activities?: ActivityMap, data?: Record<string, any>, 
+    /**
+     * Internal event queue
+     */
+    events?: EventObject[]);
     toString(): string | undefined;
 }

package/lib/State.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var constants_1 = require("./constants");
 var State = /** @class */ (function () {
-    function State(value, history, actions, activities, data, 
+    function State(value, historyValue, history, actions, activities, data, 
     /**
      * Internal event queue
      */
@@ -12,6 +12,7 @@ var State = /** @class */ (function () {
         if (data === void 0) { data = {}; }
         if (events === void 0) { events = []; }
         this.value = value;
+        this.historyValue = historyValue;
         this.history = history;
         this.actions = actions;
         this.activities = activities;
@@ -29,7 +30,7 @@ var State = /** @class */ (function () {
             if (!stateValue.actions.length) {
                 return stateValue;
             }
-            return new State(stateValue.value, stateValue.history, [], stateValue.activities);
+            return new State(stateValue.value, stateValue.historyValue, stateValue.history, [], stateValue.activities);
         }
         return State.from(stateValue);
     };