xstate 4.7.8 → 4.10.0

package/lib/json.d.ts

@@ -0,0 +1,31 @@
+import { StateNode, ActionObject, Guard, InvokeDefinition } from './';
+interface JSONFunction {
+    $function: string;
+}
+export declare function stringifyFunction(fn: Function): JSONFunction;
+interface TransitionConfig {
+    target: string[];
+    source: string;
+    actions: Array<ActionObject<any, any>>;
+    cond: Guard<any, any> | undefined;
+    eventType: string;
+}
+interface StateNodeConfig {
+    type: StateNode['type'];
+    id: string;
+    key: string;
+    initial?: string;
+    entry: Array<ActionObject<any, any>>;
+    exit: Array<ActionObject<any, any>>;
+    on: {
+        [key: string]: TransitionConfig[];
+    };
+    invoke: Array<InvokeDefinition<any, any>>;
+    states: Record<string, StateNodeConfig>;
+}
+export declare function machineToJSON(stateNode: StateNode): StateNodeConfig;
+export declare function stringify(machine: StateNode): string;
+export declare function parse(machineString: string): StateNodeConfig;
+export declare function jsonify<T extends Record<string, any>>(value: T): T;
+export {};
+//# sourceMappingURL=json.d.ts.map

package/lib/json.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+// tslint:disable-next-line:ban-types
+function stringifyFunction(fn) {
+    return {
+        $function: fn.toString()
+    };
+}
+exports.stringifyFunction = stringifyFunction;
+function getStateNodeId(stateNode) {
+    return "#" + stateNode.id;
+}
+// derive config from machine
+function machineToJSON(stateNode) {
+    var config = {
+        type: stateNode.type,
+        initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
+        id: stateNode.id,
+        key: stateNode.key,
+        entry: stateNode.onEntry,
+        exit: stateNode.onExit,
+        on: utils_1.mapValues(stateNode.on, function (transition) {
+            return transition.map(function (t) {
+                return {
+                    target: t.target ? t.target.map(getStateNodeId) : [],
+                    source: getStateNodeId(t.source),
+                    actions: t.actions,
+                    cond: t.cond,
+                    eventType: t.eventType
+                };
+            });
+        }),
+        invoke: stateNode.invoke,
+        states: {}
+    };
+    Object.values(stateNode.states).forEach(function (sn) {
+        config.states[sn.key] = machineToJSON(sn);
+    });
+    return config;
+}
+exports.machineToJSON = machineToJSON;
+function stringify(machine) {
+    return JSON.stringify(machineToJSON(machine), function (_, value) {
+        if (utils_1.isFunction(value)) {
+            return { $function: value.toString() };
+        }
+        return value;
+    });
+}
+exports.stringify = stringify;
+function parse(machineString) {
+    var config = JSON.parse(machineString, function (_, value) {
+        if (typeof value === 'object' && '$function' in value) {
+            return new Function(value.value);
+        }
+        return value;
+    });
+    return config;
+}
+exports.parse = parse;
+function jsonify(value) {
+    Object.defineProperty(value, 'toJSON', {
+        value: function () {
+            return utils_1.mapValues(value, function (subValue) {
+                if (utils_1.isFunction(subValue)) {
+                    return stringifyFunction(subValue);
+                }
+                else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
+                    // mostly for assignments
+                    return utils_1.mapValues(subValue, function (subSubValue) {
+                        if (utils_1.isFunction(subSubValue)) {
+                            return stringifyFunction(subSubValue);
+                        }
+                        return subSubValue;
+                    });
+                }
+                return subValue;
+            });
+        }
+    });
+    return value;
+}
+exports.jsonify = jsonify;

package/lib/scxml.js

@@ -30,6 +30,17 @@ var __spread = (this && this.__spread) || function () {
     for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
     return ar;
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var xml_js_1 = require("xml-js");
 var index_1 = require("./index");
@@ -103,60 +114,128 @@ var evaluateExecutableContent = function (context, _ev, meta, body) {
     var fn = new (Function.bind.apply(Function, __spread([void 0], args, [fnBody])))();
     return fn(context, meta._event);
 };
-function mapActions(elements) {
-    return elements.map(function (element) {
-        switch (element.name) {
-            case 'raise':
-                return actions.raise(element.attributes
-                    .event);
-            case 'assign':
-                return actions.assign(function (context, e, meta) {
-                    var fnBody = "\n            return {'" + element.attributes.location + "': " + element.attributes.expr + "};\n          ";
-                    return evaluateExecutableContent(context, e, meta, fnBody);
-                });
-            case 'send':
-                var _a = element.attributes, event_1 = _a.event, eventexpr_1 = _a.eventexpr, target = _a.target;
-                var convertedEvent = void 0;
-                var convertedDelay = void 0;
-                var params_1 = element.elements &&
-                    element.elements.reduce(function (acc, child) {
-                        if (child.name === 'content') {
-                            throw new Error('Conversion of <content/> inside <send/> not implemented.');
-                        }
-                        return "" + acc + child.attributes.name + ":" + child.attributes.expr + ",\n";
-                    }, '');
-                if (event_1 && !params_1) {
-                    convertedEvent = event_1;
-                }
-                else {
-                    convertedEvent = function (context, _ev, meta) {
-                        var fnBody = "\n              return { type: " + (event_1 ? "\"" + event_1 + "\"" : eventexpr_1) + ", " + (params_1 ? params_1 : '') + " }\n            ";
-                        return evaluateExecutableContent(context, _ev, meta, fnBody);
-                    };
-                }
-                if ('delay' in element.attributes) {
-                    convertedDelay = delayToMs(element.attributes.delay);
+function createCond(cond) {
+    return function (context, _event, meta) {
+        return evaluateExecutableContent(context, _event, meta, "return " + cond + ";");
+    };
+}
+function mapAction(element) {
+    var e_1, _a;
+    switch (element.name) {
+        case 'raise': {
+            return actions.raise(element.attributes.event);
+        }
+        case 'assign': {
+            return actions.assign(function (context, e, meta) {
+                var fnBody = "\n            return {'" + element.attributes.location + "': " + element.attributes.expr + "};\n          ";
+                return evaluateExecutableContent(context, e, meta, fnBody);
+            });
+        }
+        case 'send': {
+            var _b = element.attributes, event_1 = _b.event, eventexpr_1 = _b.eventexpr, target = _b.target;
+            var convertedEvent = void 0;
+            var convertedDelay = void 0;
+            var params_1 = element.elements &&
+                element.elements.reduce(function (acc, child) {
+                    if (child.name === 'content') {
+                        throw new Error('Conversion of <content/> inside <send/> not implemented.');
+                    }
+                    return "" + acc + child.attributes.name + ":" + child.attributes.expr + ",\n";
+                }, '');
+            if (event_1 && !params_1) {
+                convertedEvent = event_1;
+            }
+            else {
+                convertedEvent = function (context, _ev, meta) {
+                    var fnBody = "\n              return { type: " + (event_1 ? "\"" + event_1 + "\"" : eventexpr_1) + ", " + (params_1 ? params_1 : '') + " }\n            ";
+                    return evaluateExecutableContent(context, _ev, meta, fnBody);
+                };
+            }
+            if ('delay' in element.attributes) {
+                convertedDelay = delayToMs(element.attributes.delay);
+            }
+            else if (element.attributes.delayexpr) {
+                convertedDelay = function (context, _ev, meta) {
+                    var fnBody = "\n              return (" + delayToMs + ")(" + element.attributes.delayexpr + ");\n            ";
+                    return evaluateExecutableContent(context, _ev, meta, fnBody);
+                };
+            }
+            return actions.send(convertedEvent, {
+                delay: convertedDelay,
+                to: target
+            });
+        }
+        case 'log': {
+            var label = element.attributes.label;
+            return actions.log(function (context, e, meta) {
+                var fnBody = "\n              return " + element.attributes.expr + ";\n            ";
+                return evaluateExecutableContent(context, e, meta, fnBody);
+            }, label !== undefined ? String(label) : undefined);
+        }
+        case 'if': {
+            var conds = [];
+            var current = {
+                cond: createCond(element.attributes.cond),
+                actions: []
+            };
+            try {
+                for (var _c = __values(element.elements), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var el = _d.value;
+                    if (el.type === 'comment') {
+                        continue;
+                    }
+                    switch (el.name) {
+                        case 'elseif':
+                            conds.push(current);
+                            current = {
+                                cond: createCond(el.attributes.cond),
+                                actions: []
+                            };
+                            break;
+                        case 'else':
+                            conds.push(current);
+                            current = { actions: [] };
+                            break;
+                        default:
+                            current.actions.push(mapAction(el));
+                            break;
+                    }
                 }
-                else if (element.attributes.delayexpr) {
-                    convertedDelay = function (context, _ev, meta) {
-                        var fnBody = "\n              return (" + delayToMs + ")(" + element.attributes.delayexpr + ");\n            ";
-                        return evaluateExecutableContent(context, _ev, meta, fnBody);
-                    };
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                return actions.send(convertedEvent, {
-                    delay: convertedDelay,
-                    to: target
-                });
-            case 'log':
-                var label = element.attributes.label;
-                return actions.log(function (context, e, meta) {
-                    var fnBody = "\n              return " + element.attributes.expr + ";\n            ";
-                    return evaluateExecutableContent(context, e, meta, fnBody);
-                }, label !== undefined ? String(label) : undefined);
-            default:
-                return { type: 'not-implemented' };
+                finally { if (e_1) throw e_1.error; }
+            }
+            conds.push(current);
+            return actions.choose(conds);
         }
-    });
+        default:
+            throw new Error("Conversion of \"" + element.name + "\" elements is not implemented yet.");
+    }
+}
+function mapActions(elements) {
+    var e_2, _a;
+    var mapped = [];
+    try {
+        for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+            var element = elements_1_1.value;
+            if (element.type === 'comment') {
+                continue;
+            }
+            mapped.push(mapAction(element));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return mapped;
 }
 function toConfig(nodeJson, id, options) {
     var parallel = nodeJson.name === 'parallel';
@@ -212,10 +291,7 @@ function toConfig(nodeJson, id, options) {
             var internal = getAttribute(value, 'type') === 'internal';
             return __assign(__assign(__assign({ event: event, target: getTargets(targets) }, (value.elements ? executableContent(value.elements) : undefined)), (value.attributes && value.attributes.cond
                 ? {
-                    cond: function (context, _event, meta) {
-                        var fnBody = "\n                      return " + value.attributes.cond + ";\n                    ";
-                        return evaluateExecutableContent(context, _event, meta, fnBody);
-                    }
+                    cond: createCond(value.attributes.cond)
                 }
                 : undefined)), { internal: internal });
         });
@@ -226,8 +302,7 @@ function toConfig(nodeJson, id, options) {
             ? mapActions(onExitElement.elements)
             : undefined;
         var invoke = invokeElements.map(function (element) {
-            if (!['scxml', 'http://www.w3.org/TR/scxml/'].includes(element.attributes
-                .type)) {
+            if (!['scxml', 'http://www.w3.org/TR/scxml/'].includes(element.attributes.type)) {
                 throw new Error('Currently only converting invoke elements of type SCXML is supported.');
             }
             var content = element.elements.find(function (el) { return el.name === 'content'; });

package/lib/types.d.ts

@@ -50,7 +50,11 @@ export interface AssignMeta<TContext, TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
 }
 export declare type ActionFunction<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>) => any | void;
-export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent> | RaiseAction<AnyEventObject>;
+export interface ChooseConditon<TContext, TEvent extends EventObject> {
+    cond?: Condition<TContext, TEvent>;
+    actions: Actions<TContext, TEvent>;
+}
+export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent, AnyEventObject> | RaiseAction<AnyEventObject> | ChooseAction<TContext, TEvent>;
 export declare type Actions<TContext, TEvent extends EventObject> = SingleOrArray<Action<TContext, TEvent>>;
 export declare type StateKey = string | State<any>;
 export interface StateValueMap {
@@ -171,21 +175,28 @@ export declare type StatesConfig<TContext, TStateSchema extends StateSchema, TEv
 export declare type StatesDefinition<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
     [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K], TEvent>;
 };
-export declare type TransitionConfigTargetShortcut<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
+export declare type TransitionConfigTarget<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
+export declare type TransitionConfigOrTarget<TContext, TEvent extends EventObject> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>;
 declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
-    [K in TEvent['type'] | NullEvent['type'] | '*']?: SingleOrArray<TransitionConfigTargetShortcut<TContext, TEvent> | (TransitionConfig<TContext, K extends TEvent['type'] ? Extract<TEvent, {
+    [K in TEvent['type']]?: TransitionConfigOrTarget<TContext, TEvent extends {
         type: K;
-    }> : EventObject> & {
-        event?: undefined;
-    })>;
+    } ? TEvent : never>;
+} & {
+    ''?: TransitionConfigOrTarget<TContext, TEvent>;
+} & {
+    '*'?: TransitionConfigOrTarget<TContext, TEvent>;
 };
 declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<{
-    [K in TEvent['type'] | NullEvent['type'] | '*']: TransitionConfig<TContext, K extends TEvent['type'] ? Extract<TEvent, {
+    [K in TEvent['type']]: TransitionConfig<TContext, TEvent extends {
         type: K;
-    }> : EventObject> & {
+    } ? TEvent : never> & {
         event: K;
     };
-}[TEvent['type'] | NullEvent['type'] | '*']>;
+}[TEvent['type']] | (TransitionConfig<TContext, TEvent> & {
+    event: '';
+}) | (TransitionConfig<TContext, TEvent> & {
+    event: '*';
+})>;
 export declare type TransitionsConfig<TContext, TEvent extends EventObject> = TransitionsConfigMap<TContext, TEvent> | TransitionsConfigArray<TContext, TEvent>;
 export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
     /**
@@ -345,14 +356,15 @@ export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema,
     id: string;
     version: string | undefined;
     key: string;
+    context: TContext;
     type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
     initial: StateNodeConfig<TContext, TStateSchema, TEvent>['initial'];
     history: boolean | 'shallow' | 'deep' | undefined;
     states: StatesDefinition<TContext, TStateSchema, TEvent>;
     on: TransitionDefinitionMap<TContext, TEvent>;
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    onEntry: Array<ActionObject<TContext, TEvent>>;
-    onExit: Array<ActionObject<TContext, TEvent>>;
+    entry: Array<ActionObject<TContext, TEvent>>;
+    exit: Array<ActionObject<TContext, TEvent>>;
     activities: Array<ActivityDefinition<TContext, TEvent>>;
     meta: any;
     order: number;
@@ -478,7 +490,8 @@ export declare enum ActionTypes {
     ErrorPlatform = "error.platform",
     ErrorCustom = "xstate.error",
     Update = "xstate.update",
-    Pure = "xstate.pure"
+    Pure = "xstate.pure",
+    Choose = "xstate.choose"
 }
 export interface RaiseAction<TEvent extends EventObject> {
     type: ActionTypes.Raise;
@@ -528,22 +541,22 @@ export interface LogAction<TContext, TEvent extends EventObject> extends ActionO
 export interface LogActionObject<TContext, TEvent extends EventObject> extends LogAction<TContext, TEvent> {
     value: any;
 }
-export interface SendAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface SendAction<TContext, TEvent extends EventObject, TSentEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     to: string | number | Actor | ExprWithMeta<TContext, TEvent, string | number | Actor> | undefined;
-    event: TEvent | SendExpr<TContext, TEvent>;
+    event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>;
     delay?: number | string | DelayExpr<TContext, TEvent>;
     id: string | number;
 }
-export interface SendActionObject<TContext, TEvent extends EventObject> extends SendAction<TContext, TEvent> {
+export interface SendActionObject<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> extends SendAction<TContext, TEvent, TSentEvent> {
     to: string | number | Actor | undefined;
-    _event: SCXML.Event<TEvent>;
-    event: TEvent;
+    _event: SCXML.Event<TSentEvent>;
+    event: TSentEvent;
     delay?: number;
     id: string | number;
 }
 export declare type Expr<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent) => T;
 export declare type ExprWithMeta<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent, meta: SCXMLEventMeta<TEvent>) => T;
-export declare type SendExpr<TContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, TEvent>;
+export declare type SendExpr<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = ExprWithMeta<TContext, TEvent, TSentEvent>;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
@@ -576,12 +589,23 @@ export interface PureAction<TContext, TEvent extends EventObject> extends Action
     type: ActionTypes.Pure;
     get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent>> | undefined;
 }
+export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+    type: ActionTypes.Choose;
+    conds: Array<ChooseConditon<TContext, TEvent>>;
+}
 export interface TransitionDefinition<TContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
     target: Array<StateNode<TContext, any, TEvent>> | undefined;
     source: StateNode<TContext, any, TEvent>;
     actions: Array<ActionObject<TContext, TEvent>>;
     cond?: Guard<TContext, TEvent>;
     eventType: TEvent['type'] | NullEvent['type'] | '*';
+    toJSON: () => {
+        target: string[] | undefined;
+        source: string;
+        actions: Array<ActionObject<TContext, TEvent>>;
+        cond?: Guard<TContext, TEvent>;
+        eventType: TEvent['type'] | NullEvent['type'] | '*';
+    };
 }
 export declare type TransitionDefinitionMap<TContext, TEvent extends EventObject> = {
     [K in TEvent['type'] | NullEvent['type'] | '*']: Array<TransitionDefinition<TContext, K extends TEvent['type'] ? Extract<TEvent, {

package/lib/types.js

@@ -21,6 +21,7 @@ var ActionTypes;
     ActionTypes["ErrorCustom"] = "xstate.error";
     ActionTypes["Update"] = "xstate.update";
     ActionTypes["Pure"] = "xstate.pure";
+    ActionTypes["Choose"] = "xstate.choose";
 })(ActionTypes = exports.ActionTypes || (exports.ActionTypes = {}));
 var SpecialTargets;
 (function (SpecialTargets) {

package/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Guard, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTargetShortcut, NullEvent, SingleOrArray } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard } from './types';
 import { StateNode } from './StateNode';
 import { State } from '.';
 import { Actor } from './Actor';
@@ -59,9 +59,10 @@ export declare function isActor(value: any): value is Actor;
 export declare const uniqueId: () => string;
 export declare function toEventObject<TEvent extends EventObject>(event: Event<TEvent>, payload?: EventData): TEvent;
 export declare function toSCXMLEvent<TEvent extends EventObject>(event: Event<TEvent> | SCXML.Event<TEvent>, scxmlEvent?: Partial<SCXML.Event<TEvent>>): SCXML.Event<TEvent>;
-export declare function toTransitionConfigArray<TContext, TEvent extends EventObject>(event: TEvent['type'] | NullEvent['type'] | '*', configLike: SingleOrArray<TransitionConfig<TContext, TEvent> | TransitionConfigTargetShortcut<TContext, TEvent>>): Array<TransitionConfig<TContext, TEvent> & {
+export declare function toTransitionConfigArray<TContext, TEvent extends EventObject>(event: TEvent['type'] | NullEvent['type'] | '*', configLike: SingleOrArray<TransitionConfig<TContext, TEvent> | TransitionConfigTarget<TContext, TEvent>>): Array<TransitionConfig<TContext, TEvent> & {
     event: TEvent['type'] | NullEvent['type'] | '*';
 }>;
 export declare function normalizeTarget<TContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, any, TEvent>> | undefined): Array<string | StateNode<TContext, any, TEvent>> | undefined;
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
+export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/lib/utils.js

@@ -108,10 +108,10 @@ function toStatePath(stateId, delimiter) {
 exports.toStatePath = toStatePath;
 function isStateLike(state) {
     return (typeof state === 'object' &&
-        ('value' in state &&
-            'context' in state &&
-            'event' in state &&
-            '_event' in state));
+        'value' in state &&
+        'context' in state &&
+        'event' in state &&
+        '_event' in state);
 }
 exports.isStateLike = isStateLike;
 function toStateValue(stateValue, delimiter) {
@@ -584,3 +584,21 @@ function reportUnhandledExceptionOnInvocation(originalError, currentError, id) {
     }
 }
 exports.reportUnhandledExceptionOnInvocation = reportUnhandledExceptionOnInvocation;
+function evaluateGuard(machine, guard, context, _event, state) {
+    var guards = machine.options.guards;
+    var guardMeta = {
+        state: state,
+        cond: guard,
+        _event: _event
+    };
+    // TODO: do not hardcode!
+    if (guard.type === constants_1.DEFAULT_GUARD_TYPE) {
+        return guard.predicate(context, _event.data, guardMeta);
+    }
+    var condFn = guards[guard.type];
+    if (!condFn) {
+        throw new Error("Guard '" + guard.type + "' is not implemented on machine '" + machine.id + "'.");
+    }
+    return condFn(context, _event.data, guardMeta);
+}
+exports.evaluateGuard = evaluateGuard;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.7.8",
+  "version": "4.10.0",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -66,7 +66,7 @@
     "rxjs": "^6.5.1",
     "ts-jest": "^24.1.9",
     "tslib": "^1.10.0",
-    "typescript": "^3.7.2",
+    "typescript": "^3.8.3",
     "xml-js": "^1.6.11"
   }
 }