|
|
@@ -1,4273 +0,0 @@
|
|
|
-"use strict";
|
|
|
-(wx["webpackJsonp"] = wx["webpackJsonp"] || []).push([["vendors-node_modules_taro_weapp_prebundle_xstate_js"],{
|
|
|
-
|
|
|
-/***/ "./node_modules/.taro/weapp/prebundle/xstate.js":
|
|
|
-/*!******************************************************!*\
|
|
|
- !*** ./node_modules/.taro/weapp/prebundle/xstate.js ***!
|
|
|
- \******************************************************/
|
|
|
-/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
-
|
|
|
-__webpack_require__.r(__webpack_exports__);
|
|
|
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
-/* harmony export */ ActionTypes: function() { return /* binding */ ActionTypes; },
|
|
|
-/* harmony export */ Interpreter: function() { return /* binding */ Interpreter; },
|
|
|
-/* harmony export */ InterpreterStatus: function() { return /* binding */ InterpreterStatus; },
|
|
|
-/* harmony export */ Machine: function() { return /* binding */ Machine; },
|
|
|
-/* harmony export */ SpecialTargets: function() { return /* binding */ SpecialTargets; },
|
|
|
-/* harmony export */ State: function() { return /* binding */ State; },
|
|
|
-/* harmony export */ StateNode: function() { return /* binding */ StateNode; },
|
|
|
-/* harmony export */ actions: function() { return /* binding */ actions_exports; },
|
|
|
-/* harmony export */ assign: function() { return /* binding */ assign3; },
|
|
|
-/* harmony export */ cancel: function() { return /* binding */ cancel3; },
|
|
|
-/* harmony export */ choose: function() { return /* binding */ choose3; },
|
|
|
-/* harmony export */ createMachine: function() { return /* binding */ createMachine; },
|
|
|
-/* harmony export */ createSchema: function() { return /* binding */ createSchema; },
|
|
|
-/* harmony export */ doneInvoke: function() { return /* binding */ doneInvoke2; },
|
|
|
-/* harmony export */ forwardTo: function() { return /* binding */ forwardTo2; },
|
|
|
-/* harmony export */ interpret: function() { return /* binding */ interpret; },
|
|
|
-/* harmony export */ log: function() { return /* binding */ log3; },
|
|
|
-/* harmony export */ mapState: function() { return /* binding */ mapState; },
|
|
|
-/* harmony export */ matchState: function() { return /* binding */ matchState; },
|
|
|
-/* harmony export */ matchesState: function() { return /* binding */ matchesState; },
|
|
|
-/* harmony export */ pure: function() { return /* binding */ pure3; },
|
|
|
-/* harmony export */ raise: function() { return /* binding */ raise3; },
|
|
|
-/* harmony export */ send: function() { return /* binding */ send3; },
|
|
|
-/* harmony export */ sendParent: function() { return /* binding */ sendParent2; },
|
|
|
-/* harmony export */ sendTo: function() { return /* binding */ sendTo2; },
|
|
|
-/* harmony export */ sendUpdate: function() { return /* binding */ sendUpdate2; },
|
|
|
-/* harmony export */ spawn: function() { return /* binding */ spawn; },
|
|
|
-/* harmony export */ spawnBehavior: function() { return /* binding */ spawnBehavior; },
|
|
|
-/* harmony export */ stop: function() { return /* binding */ stop3; },
|
|
|
-/* harmony export */ t: function() { return /* binding */ t; },
|
|
|
-/* harmony export */ toActorRef: function() { return /* binding */ toActorRef; },
|
|
|
-/* harmony export */ toEventObject: function() { return /* binding */ toEventObject; },
|
|
|
-/* harmony export */ toObserver: function() { return /* binding */ toObserver; },
|
|
|
-/* harmony export */ toSCXMLEvent: function() { return /* binding */ toSCXMLEvent; }
|
|
|
-/* harmony export */ });
|
|
|
-/* harmony import */ var _chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./chunk-P7VEE7PG.js */ "./node_modules/.taro/weapp/prebundle/chunk-P7VEE7PG.js");
|
|
|
-/* provided dependency */ var window = __webpack_require__(/*! ./node_modules/.taro/weapp/prebundle/chunk-3EXGJ5BE.js */ "./node_modules/.taro/weapp/prebundle/chunk-3EXGJ5BE.js")["window$1"];
|
|
|
-
|
|
|
-// node_modules/xstate/es/actions.js
|
|
|
-var actions_exports = {};
|
|
|
-(0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_0__.__export)(actions_exports, {
|
|
|
- actionTypes: ()=>actionTypes_exports,
|
|
|
- after: ()=>after2,
|
|
|
- assign: ()=>assign2,
|
|
|
- cancel: ()=>cancel2,
|
|
|
- choose: ()=>choose2,
|
|
|
- done: ()=>done,
|
|
|
- doneInvoke: ()=>doneInvoke,
|
|
|
- error: ()=>error2,
|
|
|
- escalate: ()=>escalate,
|
|
|
- forwardTo: ()=>forwardTo,
|
|
|
- getActionFunction: ()=>getActionFunction,
|
|
|
- initEvent: ()=>initEvent,
|
|
|
- isActionObject: ()=>isActionObject,
|
|
|
- log: ()=>log2,
|
|
|
- pure: ()=>pure2,
|
|
|
- raise: ()=>raise2,
|
|
|
- resolveActions: ()=>resolveActions,
|
|
|
- resolveLog: ()=>resolveLog,
|
|
|
- resolveRaise: ()=>resolveRaise,
|
|
|
- resolveSend: ()=>resolveSend,
|
|
|
- resolveStop: ()=>resolveStop,
|
|
|
- respond: ()=>respond,
|
|
|
- send: ()=>send2,
|
|
|
- sendParent: ()=>sendParent,
|
|
|
- sendTo: ()=>sendTo,
|
|
|
- sendUpdate: ()=>sendUpdate,
|
|
|
- start: ()=>start2,
|
|
|
- stop: ()=>stop2,
|
|
|
- toActionObject: ()=>toActionObject,
|
|
|
- toActionObjects: ()=>toActionObjects,
|
|
|
- toActivityDefinition: ()=>toActivityDefinition
|
|
|
-});
|
|
|
-// node_modules/xstate/es/_virtual/_tslib.js
|
|
|
-var __assign = function() {
|
|
|
- __assign = Object.assign || function __assign2(t2) {
|
|
|
- for(var s, i = 1, n = arguments.length; i < n; i++){
|
|
|
- s = arguments[i];
|
|
|
- for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p)) t2[p] = s[p];
|
|
|
- }
|
|
|
- return t2;
|
|
|
- };
|
|
|
- return __assign.apply(this, arguments);
|
|
|
-};
|
|
|
-function __rest(s, e) {
|
|
|
- var t2 = {};
|
|
|
- for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t2[p] = s[p];
|
|
|
- if (s != null && typeof Object.getOwnPropertySymbols === "function") for(var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++){
|
|
|
- if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t2[p[i]] = s[p[i]];
|
|
|
- }
|
|
|
- return t2;
|
|
|
-}
|
|
|
-function __values(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.");
|
|
|
-}
|
|
|
-function __read(o, n) {
|
|
|
- var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
|
- if (!m) return o;
|
|
|
- var i = m.call(o), r, ar = [], e;
|
|
|
- try {
|
|
|
- while((n === void 0 || n-- > 0) && !(r = i.next()).done)ar.push(r.value);
|
|
|
- } catch (error3) {
|
|
|
- e = {
|
|
|
- error: error3
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (r && !r.done && (m = i["return"])) m.call(i);
|
|
|
- } finally{
|
|
|
- if (e) throw e.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return ar;
|
|
|
-}
|
|
|
-function __spreadArray(to, from, pack) {
|
|
|
- if (pack || arguments.length === 2) for(var i = 0, l = from.length, ar; i < l; i++){
|
|
|
- if (ar || !(i in from)) {
|
|
|
- if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
|
- ar[i] = from[i];
|
|
|
- }
|
|
|
- }
|
|
|
- return to.concat(ar || Array.prototype.slice.call(from));
|
|
|
-}
|
|
|
-// node_modules/xstate/es/types.js
|
|
|
-var ActionTypes;
|
|
|
-(function(ActionTypes2) {
|
|
|
- ActionTypes2["Start"] = "xstate.start";
|
|
|
- ActionTypes2["Stop"] = "xstate.stop";
|
|
|
- ActionTypes2["Raise"] = "xstate.raise";
|
|
|
- ActionTypes2["Send"] = "xstate.send";
|
|
|
- ActionTypes2["Cancel"] = "xstate.cancel";
|
|
|
- ActionTypes2["NullEvent"] = "";
|
|
|
- ActionTypes2["Assign"] = "xstate.assign";
|
|
|
- ActionTypes2["After"] = "xstate.after";
|
|
|
- ActionTypes2["DoneState"] = "done.state";
|
|
|
- ActionTypes2["DoneInvoke"] = "done.invoke";
|
|
|
- ActionTypes2["Log"] = "xstate.log";
|
|
|
- ActionTypes2["Init"] = "xstate.init";
|
|
|
- ActionTypes2["Invoke"] = "xstate.invoke";
|
|
|
- ActionTypes2["ErrorExecution"] = "error.execution";
|
|
|
- ActionTypes2["ErrorCommunication"] = "error.communication";
|
|
|
- ActionTypes2["ErrorPlatform"] = "error.platform";
|
|
|
- ActionTypes2["ErrorCustom"] = "xstate.error";
|
|
|
- ActionTypes2["Update"] = "xstate.update";
|
|
|
- ActionTypes2["Pure"] = "xstate.pure";
|
|
|
- ActionTypes2["Choose"] = "xstate.choose";
|
|
|
-})(ActionTypes || (ActionTypes = {}));
|
|
|
-var SpecialTargets;
|
|
|
-(function(SpecialTargets2) {
|
|
|
- SpecialTargets2["Parent"] = "#_parent";
|
|
|
- SpecialTargets2["Internal"] = "#_internal";
|
|
|
-})(SpecialTargets || (SpecialTargets = {}));
|
|
|
-// node_modules/xstate/es/actionTypes.js
|
|
|
-var actionTypes_exports = {};
|
|
|
-(0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_0__.__export)(actionTypes_exports, {
|
|
|
- after: ()=>after,
|
|
|
- assign: ()=>assign,
|
|
|
- cancel: ()=>cancel,
|
|
|
- choose: ()=>choose,
|
|
|
- doneState: ()=>doneState,
|
|
|
- error: ()=>error,
|
|
|
- errorExecution: ()=>errorExecution,
|
|
|
- errorPlatform: ()=>errorPlatform,
|
|
|
- init: ()=>init,
|
|
|
- invoke: ()=>invoke,
|
|
|
- log: ()=>log,
|
|
|
- nullEvent: ()=>nullEvent,
|
|
|
- pure: ()=>pure,
|
|
|
- raise: ()=>raise,
|
|
|
- send: ()=>send,
|
|
|
- start: ()=>start,
|
|
|
- stop: ()=>stop,
|
|
|
- update: ()=>update
|
|
|
-});
|
|
|
-var start = ActionTypes.Start;
|
|
|
-var stop = ActionTypes.Stop;
|
|
|
-var raise = ActionTypes.Raise;
|
|
|
-var send = ActionTypes.Send;
|
|
|
-var cancel = ActionTypes.Cancel;
|
|
|
-var nullEvent = ActionTypes.NullEvent;
|
|
|
-var assign = ActionTypes.Assign;
|
|
|
-var after = ActionTypes.After;
|
|
|
-var doneState = ActionTypes.DoneState;
|
|
|
-var log = ActionTypes.Log;
|
|
|
-var init = ActionTypes.Init;
|
|
|
-var invoke = ActionTypes.Invoke;
|
|
|
-var errorExecution = ActionTypes.ErrorExecution;
|
|
|
-var errorPlatform = ActionTypes.ErrorPlatform;
|
|
|
-var error = ActionTypes.ErrorCustom;
|
|
|
-var update = ActionTypes.Update;
|
|
|
-var choose = ActionTypes.Choose;
|
|
|
-var pure = ActionTypes.Pure;
|
|
|
-// node_modules/xstate/es/constants.js
|
|
|
-var STATE_DELIMITER = ".";
|
|
|
-var EMPTY_ACTIVITY_MAP = {};
|
|
|
-var DEFAULT_GUARD_TYPE = "xstate.guard";
|
|
|
-var TARGETLESS_KEY = "";
|
|
|
-// node_modules/xstate/es/environment.js
|
|
|
-var IS_PRODUCTION = false;
|
|
|
-// node_modules/xstate/es/utils.js
|
|
|
-var _a;
|
|
|
-function matchesState(parentStateId, childStateId, delimiter) {
|
|
|
- if (delimiter === void 0) {
|
|
|
- delimiter = STATE_DELIMITER;
|
|
|
- }
|
|
|
- var parentStateValue = toStateValue(parentStateId, delimiter);
|
|
|
- var childStateValue = toStateValue(childStateId, delimiter);
|
|
|
- if (isString(childStateValue)) {
|
|
|
- if (isString(parentStateValue)) {
|
|
|
- return childStateValue === parentStateValue;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (isString(parentStateValue)) {
|
|
|
- return parentStateValue in childStateValue;
|
|
|
- }
|
|
|
- return Object.keys(parentStateValue).every(function(key) {
|
|
|
- if (!(key in childStateValue)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return matchesState(parentStateValue[key], childStateValue[key]);
|
|
|
- });
|
|
|
-}
|
|
|
-function getEventType(event2) {
|
|
|
- try {
|
|
|
- return isString(event2) || typeof event2 === "number" ? "".concat(event2) : event2.type;
|
|
|
- } catch (e) {
|
|
|
- throw new Error("Events must be strings or objects with a string event.type property.");
|
|
|
- }
|
|
|
-}
|
|
|
-function toStatePath(stateId, delimiter) {
|
|
|
- try {
|
|
|
- if (isArray(stateId)) {
|
|
|
- return stateId;
|
|
|
- }
|
|
|
- return stateId.toString().split(delimiter);
|
|
|
- } catch (e) {
|
|
|
- throw new Error("'".concat(stateId, "' is not a valid state path."));
|
|
|
- }
|
|
|
-}
|
|
|
-function isStateLike(state) {
|
|
|
- return typeof state === "object" && "value" in state && "context" in state && "event" in state && "_event" in state;
|
|
|
-}
|
|
|
-function toStateValue(stateValue, delimiter) {
|
|
|
- if (isStateLike(stateValue)) {
|
|
|
- return stateValue.value;
|
|
|
- }
|
|
|
- if (isArray(stateValue)) {
|
|
|
- return pathToStateValue(stateValue);
|
|
|
- }
|
|
|
- if (typeof stateValue !== "string") {
|
|
|
- return stateValue;
|
|
|
- }
|
|
|
- var statePath = toStatePath(stateValue, delimiter);
|
|
|
- return pathToStateValue(statePath);
|
|
|
-}
|
|
|
-function pathToStateValue(statePath) {
|
|
|
- if (statePath.length === 1) {
|
|
|
- return statePath[0];
|
|
|
- }
|
|
|
- var value = {};
|
|
|
- var marker = value;
|
|
|
- for(var i = 0; i < statePath.length - 1; i++){
|
|
|
- if (i === statePath.length - 2) {
|
|
|
- marker[statePath[i]] = statePath[i + 1];
|
|
|
- } else {
|
|
|
- marker[statePath[i]] = {};
|
|
|
- marker = marker[statePath[i]];
|
|
|
- }
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-function mapValues(collection, iteratee) {
|
|
|
- var result = {};
|
|
|
- var collectionKeys = Object.keys(collection);
|
|
|
- for(var i = 0; i < collectionKeys.length; i++){
|
|
|
- var key = collectionKeys[i];
|
|
|
- result[key] = iteratee(collection[key], key, collection, i);
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-function mapFilterValues(collection, iteratee, predicate) {
|
|
|
- var e_1, _a2;
|
|
|
- var result = {};
|
|
|
- try {
|
|
|
- for(var _b = __values(Object.keys(collection)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var key = _c.value;
|
|
|
- var item = collection[key];
|
|
|
- if (!predicate(item)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- result[key] = iteratee(item, key, collection);
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-var path = function(props) {
|
|
|
- return function(object) {
|
|
|
- var e_2, _a2;
|
|
|
- var result = object;
|
|
|
- try {
|
|
|
- for(var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()){
|
|
|
- var prop = props_1_1.value;
|
|
|
- result = result[prop];
|
|
|
- }
|
|
|
- } catch (e_2_1) {
|
|
|
- e_2 = {
|
|
|
- error: e_2_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (props_1_1 && !props_1_1.done && (_a2 = props_1.return)) _a2.call(props_1);
|
|
|
- } finally{
|
|
|
- if (e_2) throw e_2.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
-};
|
|
|
-function nestedPath(props, accessorProp) {
|
|
|
- return function(object) {
|
|
|
- var e_3, _a2;
|
|
|
- var result = object;
|
|
|
- try {
|
|
|
- for(var props_2 = __values(props), props_2_1 = props_2.next(); !props_2_1.done; props_2_1 = props_2.next()){
|
|
|
- var prop = props_2_1.value;
|
|
|
- result = result[accessorProp][prop];
|
|
|
- }
|
|
|
- } catch (e_3_1) {
|
|
|
- e_3 = {
|
|
|
- error: e_3_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (props_2_1 && !props_2_1.done && (_a2 = props_2.return)) _a2.call(props_2);
|
|
|
- } finally{
|
|
|
- if (e_3) throw e_3.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
-}
|
|
|
-function toStatePaths(stateValue) {
|
|
|
- if (!stateValue) {
|
|
|
- return [
|
|
|
- []
|
|
|
- ];
|
|
|
- }
|
|
|
- if (isString(stateValue)) {
|
|
|
- return [
|
|
|
- [
|
|
|
- stateValue
|
|
|
- ]
|
|
|
- ];
|
|
|
- }
|
|
|
- var result = flatten(Object.keys(stateValue).map(function(key) {
|
|
|
- var subStateValue = stateValue[key];
|
|
|
- if (typeof subStateValue !== "string" && (!subStateValue || !Object.keys(subStateValue).length)) {
|
|
|
- return [
|
|
|
- [
|
|
|
- key
|
|
|
- ]
|
|
|
- ];
|
|
|
- }
|
|
|
- return toStatePaths(stateValue[key]).map(function(subPath) {
|
|
|
- return [
|
|
|
- key
|
|
|
- ].concat(subPath);
|
|
|
- });
|
|
|
- }));
|
|
|
- return result;
|
|
|
-}
|
|
|
-function flatten(array) {
|
|
|
- var _a2;
|
|
|
- return (_a2 = []).concat.apply(_a2, __spreadArray([], __read(array), false));
|
|
|
-}
|
|
|
-function toArrayStrict(value) {
|
|
|
- if (isArray(value)) {
|
|
|
- return value;
|
|
|
- }
|
|
|
- return [
|
|
|
- value
|
|
|
- ];
|
|
|
-}
|
|
|
-function toArray(value) {
|
|
|
- if (value === void 0) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- return toArrayStrict(value);
|
|
|
-}
|
|
|
-function mapContext(mapper, context, _event) {
|
|
|
- var e_5, _a2;
|
|
|
- if (isFunction(mapper)) {
|
|
|
- return mapper(context, _event.data);
|
|
|
- }
|
|
|
- var result = {};
|
|
|
- try {
|
|
|
- for(var _b = __values(Object.keys(mapper)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var key = _c.value;
|
|
|
- var subMapper = mapper[key];
|
|
|
- if (isFunction(subMapper)) {
|
|
|
- result[key] = subMapper(context, _event.data);
|
|
|
- } else {
|
|
|
- result[key] = subMapper;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_5_1) {
|
|
|
- e_5 = {
|
|
|
- error: e_5_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_5) throw e_5.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-function isBuiltInEvent(eventType) {
|
|
|
- return /^(done|error)\./.test(eventType);
|
|
|
-}
|
|
|
-function isPromiseLike(value) {
|
|
|
- if (value instanceof Promise) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (value !== null && (isFunction(value) || typeof value === "object") && isFunction(value.then)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function isBehavior(value) {
|
|
|
- return value !== null && typeof value === "object" && "transition" in value && typeof value.transition === "function";
|
|
|
-}
|
|
|
-function partition(items, predicate) {
|
|
|
- var e_6, _a2;
|
|
|
- var _b = __read([
|
|
|
- [],
|
|
|
- []
|
|
|
- ], 2), truthy = _b[0], falsy = _b[1];
|
|
|
- try {
|
|
|
- for(var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()){
|
|
|
- var item = items_1_1.value;
|
|
|
- if (predicate(item)) {
|
|
|
- truthy.push(item);
|
|
|
- } else {
|
|
|
- falsy.push(item);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_6_1) {
|
|
|
- e_6 = {
|
|
|
- error: e_6_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (items_1_1 && !items_1_1.done && (_a2 = items_1.return)) _a2.call(items_1);
|
|
|
- } finally{
|
|
|
- if (e_6) throw e_6.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return [
|
|
|
- truthy,
|
|
|
- falsy
|
|
|
- ];
|
|
|
-}
|
|
|
-function updateHistoryStates(hist, stateValue) {
|
|
|
- return mapValues(hist.states, function(subHist, key) {
|
|
|
- if (!subHist) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- var subStateValue = (isString(stateValue) ? void 0 : stateValue[key]) || (subHist ? subHist.current : void 0);
|
|
|
- if (!subStateValue) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return {
|
|
|
- current: subStateValue,
|
|
|
- states: updateHistoryStates(subHist, subStateValue)
|
|
|
- };
|
|
|
- });
|
|
|
-}
|
|
|
-function updateHistoryValue(hist, stateValue) {
|
|
|
- return {
|
|
|
- current: stateValue,
|
|
|
- states: updateHistoryStates(hist, stateValue)
|
|
|
- };
|
|
|
-}
|
|
|
-function updateContext(context, _event, assignActions, state) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(!!context, "Attempting to update undefined context");
|
|
|
- }
|
|
|
- var updatedContext = context ? assignActions.reduce(function(acc, assignAction) {
|
|
|
- var e_7, _a2;
|
|
|
- var assignment = assignAction.assignment;
|
|
|
- var meta = {
|
|
|
- state,
|
|
|
- action: assignAction,
|
|
|
- _event
|
|
|
- };
|
|
|
- var partialUpdate = {};
|
|
|
- if (isFunction(assignment)) {
|
|
|
- partialUpdate = assignment(acc, _event.data, meta);
|
|
|
- } else {
|
|
|
- try {
|
|
|
- for(var _b = __values(Object.keys(assignment)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var key = _c.value;
|
|
|
- var propAssignment = assignment[key];
|
|
|
- partialUpdate[key] = isFunction(propAssignment) ? propAssignment(acc, _event.data, meta) : propAssignment;
|
|
|
- }
|
|
|
- } catch (e_7_1) {
|
|
|
- e_7 = {
|
|
|
- error: e_7_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_7) throw e_7.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return Object.assign({}, acc, partialUpdate);
|
|
|
- }, context) : context;
|
|
|
- return updatedContext;
|
|
|
-}
|
|
|
-var warn = function() {};
|
|
|
-if (!IS_PRODUCTION) {
|
|
|
- warn = function(condition, message) {
|
|
|
- var error3 = condition instanceof Error ? condition : void 0;
|
|
|
- if (!error3 && condition) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (console !== void 0) {
|
|
|
- var args = [
|
|
|
- "Warning: ".concat(message)
|
|
|
- ];
|
|
|
- if (error3) {
|
|
|
- args.push(error3);
|
|
|
- }
|
|
|
- console.warn.apply(console, args);
|
|
|
- }
|
|
|
- };
|
|
|
-}
|
|
|
-function isArray(value) {
|
|
|
- return Array.isArray(value);
|
|
|
-}
|
|
|
-function isFunction(value) {
|
|
|
- return typeof value === "function";
|
|
|
-}
|
|
|
-function isString(value) {
|
|
|
- return typeof value === "string";
|
|
|
-}
|
|
|
-function toGuard(condition, guardMap) {
|
|
|
- if (!condition) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- if (isString(condition)) {
|
|
|
- return {
|
|
|
- type: DEFAULT_GUARD_TYPE,
|
|
|
- name: condition,
|
|
|
- predicate: guardMap ? guardMap[condition] : void 0
|
|
|
- };
|
|
|
- }
|
|
|
- if (isFunction(condition)) {
|
|
|
- return {
|
|
|
- type: DEFAULT_GUARD_TYPE,
|
|
|
- name: condition.name,
|
|
|
- predicate: condition
|
|
|
- };
|
|
|
- }
|
|
|
- return condition;
|
|
|
-}
|
|
|
-function isObservable(value) {
|
|
|
- try {
|
|
|
- return "subscribe" in value && isFunction(value.subscribe);
|
|
|
- } catch (e) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-}
|
|
|
-var symbolObservable = function() {
|
|
|
- return typeof Symbol === "function" && Symbol.observable || "@@observable";
|
|
|
-}();
|
|
|
-var interopSymbols = (_a = {}, _a[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
-}, _a[Symbol.observable] = function() {
|
|
|
- return this;
|
|
|
-}, _a);
|
|
|
-function isMachine(value) {
|
|
|
- return !!value && "__xstatenode" in value;
|
|
|
-}
|
|
|
-function isActor(value) {
|
|
|
- return !!value && typeof value.send === "function";
|
|
|
-}
|
|
|
-var uniqueId = function() {
|
|
|
- var currentId = 0;
|
|
|
- return function() {
|
|
|
- currentId++;
|
|
|
- return currentId.toString(16);
|
|
|
- };
|
|
|
-}();
|
|
|
-function toEventObject(event2, payload) {
|
|
|
- if (isString(event2) || typeof event2 === "number") {
|
|
|
- return __assign({
|
|
|
- type: event2
|
|
|
- }, payload);
|
|
|
- }
|
|
|
- return event2;
|
|
|
-}
|
|
|
-function toSCXMLEvent(event2, scxmlEvent) {
|
|
|
- if (!isString(event2) && "$$type" in event2 && event2.$$type === "scxml") {
|
|
|
- return event2;
|
|
|
- }
|
|
|
- var eventObject = toEventObject(event2);
|
|
|
- return __assign({
|
|
|
- name: eventObject.type,
|
|
|
- data: eventObject,
|
|
|
- $$type: "scxml",
|
|
|
- type: "external"
|
|
|
- }, scxmlEvent);
|
|
|
-}
|
|
|
-function toTransitionConfigArray(event2, configLike) {
|
|
|
- var transitions = toArrayStrict(configLike).map(function(transitionLike) {
|
|
|
- if (typeof transitionLike === "undefined" || typeof transitionLike === "string" || isMachine(transitionLike)) {
|
|
|
- return {
|
|
|
- target: transitionLike,
|
|
|
- event: event2
|
|
|
- };
|
|
|
- }
|
|
|
- return __assign(__assign({}, transitionLike), {
|
|
|
- event: event2
|
|
|
- });
|
|
|
- });
|
|
|
- return transitions;
|
|
|
-}
|
|
|
-function normalizeTarget(target) {
|
|
|
- if (target === void 0 || target === TARGETLESS_KEY) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return toArray(target);
|
|
|
-}
|
|
|
-function reportUnhandledExceptionOnInvocation(originalError, currentError, id) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- var originalStackTrace = originalError.stack ? " Stacktrace was '".concat(originalError.stack, "'") : "";
|
|
|
- if (originalError === currentError) {
|
|
|
- console.error("Missing onError handler for invocation '".concat(id, "', error was '").concat(originalError, "'.").concat(originalStackTrace));
|
|
|
- } else {
|
|
|
- var stackTrace = currentError.stack ? " Stacktrace was '".concat(currentError.stack, "'") : "";
|
|
|
- console.error("Missing onError handler and/or unhandled exception/promise rejection for invocation '".concat(id, "'. ") + "Original error: '".concat(originalError, "'. ").concat(originalStackTrace, " Current error is '").concat(currentError, "'.").concat(stackTrace));
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function evaluateGuard(machine, guard, context, _event, state) {
|
|
|
- var guards = machine.options.guards;
|
|
|
- var guardMeta = {
|
|
|
- state,
|
|
|
- cond: guard,
|
|
|
- _event
|
|
|
- };
|
|
|
- if (guard.type === DEFAULT_GUARD_TYPE) {
|
|
|
- return ((guards === null || guards === void 0 ? void 0 : guards[guard.name]) || guard.predicate)(context, _event.data, guardMeta);
|
|
|
- }
|
|
|
- var condFn = guards === null || guards === void 0 ? void 0 : guards[guard.type];
|
|
|
- if (!condFn) {
|
|
|
- throw new Error("Guard '".concat(guard.type, "' is not implemented on machine '").concat(machine.id, "'."));
|
|
|
- }
|
|
|
- return condFn(context, _event.data, guardMeta);
|
|
|
-}
|
|
|
-function toInvokeSource(src) {
|
|
|
- if (typeof src === "string") {
|
|
|
- return {
|
|
|
- type: src
|
|
|
- };
|
|
|
- }
|
|
|
- return src;
|
|
|
-}
|
|
|
-function toObserver(nextHandler, errorHandler, completionHandler) {
|
|
|
- var noop = function() {};
|
|
|
- var isObserver = typeof nextHandler === "object";
|
|
|
- var self2 = isObserver ? nextHandler : null;
|
|
|
- return {
|
|
|
- next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self2),
|
|
|
- error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self2),
|
|
|
- complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self2)
|
|
|
- };
|
|
|
-}
|
|
|
-function createInvokeId(stateNodeId, index) {
|
|
|
- return "".concat(stateNodeId, ":invocation[").concat(index, "]");
|
|
|
-}
|
|
|
-function isRaisableAction(action) {
|
|
|
- return (action.type === raise || action.type === send && action.to === SpecialTargets.Internal) && typeof action.delay !== "number";
|
|
|
-}
|
|
|
-// node_modules/xstate/es/actions.js
|
|
|
-var initEvent = toSCXMLEvent({
|
|
|
- type: init
|
|
|
-});
|
|
|
-function getActionFunction(actionType, actionFunctionMap) {
|
|
|
- return actionFunctionMap ? actionFunctionMap[actionType] || void 0 : void 0;
|
|
|
-}
|
|
|
-function toActionObject(action, actionFunctionMap) {
|
|
|
- var actionObject;
|
|
|
- if (isString(action) || typeof action === "number") {
|
|
|
- var exec = getActionFunction(action, actionFunctionMap);
|
|
|
- if (isFunction(exec)) {
|
|
|
- actionObject = {
|
|
|
- type: action,
|
|
|
- exec
|
|
|
- };
|
|
|
- } else if (exec) {
|
|
|
- actionObject = exec;
|
|
|
- } else {
|
|
|
- actionObject = {
|
|
|
- type: action,
|
|
|
- exec: void 0
|
|
|
- };
|
|
|
- }
|
|
|
- } else if (isFunction(action)) {
|
|
|
- actionObject = {
|
|
|
- type: action.name || action.toString(),
|
|
|
- exec: action
|
|
|
- };
|
|
|
- } else {
|
|
|
- var exec = getActionFunction(action.type, actionFunctionMap);
|
|
|
- if (isFunction(exec)) {
|
|
|
- actionObject = __assign(__assign({}, action), {
|
|
|
- exec
|
|
|
- });
|
|
|
- } else if (exec) {
|
|
|
- var actionType = exec.type || action.type;
|
|
|
- actionObject = __assign(__assign(__assign({}, exec), action), {
|
|
|
- type: actionType
|
|
|
- });
|
|
|
- } else {
|
|
|
- actionObject = action;
|
|
|
- }
|
|
|
- }
|
|
|
- return actionObject;
|
|
|
-}
|
|
|
-var toActionObjects = function(action, actionFunctionMap) {
|
|
|
- if (!action) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- var actions = isArray(action) ? action : [
|
|
|
- action
|
|
|
- ];
|
|
|
- return actions.map(function(subAction) {
|
|
|
- return toActionObject(subAction, actionFunctionMap);
|
|
|
- });
|
|
|
-};
|
|
|
-function toActivityDefinition(action) {
|
|
|
- var actionObject = toActionObject(action);
|
|
|
- return __assign(__assign({
|
|
|
- id: isString(action) ? action : actionObject.id
|
|
|
- }, actionObject), {
|
|
|
- type: actionObject.type
|
|
|
- });
|
|
|
-}
|
|
|
-function raise2(event2, options) {
|
|
|
- return {
|
|
|
- type: raise,
|
|
|
- event: typeof event2 === "function" ? event2 : toEventObject(event2),
|
|
|
- delay: options ? options.delay : void 0,
|
|
|
- id: options === null || options === void 0 ? void 0 : options.id
|
|
|
- };
|
|
|
-}
|
|
|
-function resolveRaise(action, ctx, _event, delaysMap) {
|
|
|
- var meta = {
|
|
|
- _event
|
|
|
- };
|
|
|
- var resolvedEvent = toSCXMLEvent(isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
|
|
|
- var resolvedDelay;
|
|
|
- if (isString(action.delay)) {
|
|
|
- var configDelay = delaysMap && delaysMap[action.delay];
|
|
|
- resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
|
|
|
- } else {
|
|
|
- resolvedDelay = isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
|
|
|
- }
|
|
|
- return __assign(__assign({}, action), {
|
|
|
- type: raise,
|
|
|
- _event: resolvedEvent,
|
|
|
- delay: resolvedDelay
|
|
|
- });
|
|
|
-}
|
|
|
-function send2(event2, options) {
|
|
|
- return {
|
|
|
- to: options ? options.to : void 0,
|
|
|
- type: send,
|
|
|
- event: isFunction(event2) ? event2 : toEventObject(event2),
|
|
|
- delay: options ? options.delay : void 0,
|
|
|
- id: options && options.id !== void 0 ? options.id : isFunction(event2) ? event2.name : getEventType(event2)
|
|
|
- };
|
|
|
-}
|
|
|
-function resolveSend(action, ctx, _event, delaysMap) {
|
|
|
- var meta = {
|
|
|
- _event
|
|
|
- };
|
|
|
- var resolvedEvent = toSCXMLEvent(isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
|
|
|
- var resolvedDelay;
|
|
|
- if (isString(action.delay)) {
|
|
|
- var configDelay = delaysMap && delaysMap[action.delay];
|
|
|
- resolvedDelay = isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
|
|
|
- } else {
|
|
|
- resolvedDelay = isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
|
|
|
- }
|
|
|
- var resolvedTarget = isFunction(action.to) ? action.to(ctx, _event.data, meta) : action.to;
|
|
|
- return __assign(__assign({}, action), {
|
|
|
- to: resolvedTarget,
|
|
|
- _event: resolvedEvent,
|
|
|
- event: resolvedEvent.data,
|
|
|
- delay: resolvedDelay
|
|
|
- });
|
|
|
-}
|
|
|
-function sendParent(event2, options) {
|
|
|
- return send2(event2, __assign(__assign({}, options), {
|
|
|
- to: SpecialTargets.Parent
|
|
|
- }));
|
|
|
-}
|
|
|
-function sendTo(actor, event2, options) {
|
|
|
- return send2(event2, __assign(__assign({}, options), {
|
|
|
- to: actor
|
|
|
- }));
|
|
|
-}
|
|
|
-function sendUpdate() {
|
|
|
- return sendParent(update);
|
|
|
-}
|
|
|
-function respond(event2, options) {
|
|
|
- return send2(event2, __assign(__assign({}, options), {
|
|
|
- to: function(_, __, _a2) {
|
|
|
- var _event = _a2._event;
|
|
|
- return _event.origin;
|
|
|
- }
|
|
|
- }));
|
|
|
-}
|
|
|
-var defaultLogExpr = function(context, event2) {
|
|
|
- return {
|
|
|
- context,
|
|
|
- event: event2
|
|
|
- };
|
|
|
-};
|
|
|
-function log2(expr, label) {
|
|
|
- if (expr === void 0) {
|
|
|
- expr = defaultLogExpr;
|
|
|
- }
|
|
|
- return {
|
|
|
- type: log,
|
|
|
- label,
|
|
|
- expr
|
|
|
- };
|
|
|
-}
|
|
|
-var resolveLog = function(action, ctx, _event) {
|
|
|
- return __assign(__assign({}, action), {
|
|
|
- value: isString(action.expr) ? action.expr : action.expr(ctx, _event.data, {
|
|
|
- _event
|
|
|
- })
|
|
|
- });
|
|
|
-};
|
|
|
-var cancel2 = function(sendId) {
|
|
|
- return {
|
|
|
- type: cancel,
|
|
|
- sendId
|
|
|
- };
|
|
|
-};
|
|
|
-function start2(activity) {
|
|
|
- var activityDef = toActivityDefinition(activity);
|
|
|
- return {
|
|
|
- type: ActionTypes.Start,
|
|
|
- activity: activityDef,
|
|
|
- exec: void 0
|
|
|
- };
|
|
|
-}
|
|
|
-function stop2(actorRef) {
|
|
|
- var activity = isFunction(actorRef) ? actorRef : toActivityDefinition(actorRef);
|
|
|
- return {
|
|
|
- type: ActionTypes.Stop,
|
|
|
- activity,
|
|
|
- exec: void 0
|
|
|
- };
|
|
|
-}
|
|
|
-function resolveStop(action, context, _event) {
|
|
|
- var actorRefOrString = isFunction(action.activity) ? action.activity(context, _event.data) : action.activity;
|
|
|
- var resolvedActorRef = typeof actorRefOrString === "string" ? {
|
|
|
- id: actorRefOrString
|
|
|
- } : actorRefOrString;
|
|
|
- var actionObject = {
|
|
|
- type: ActionTypes.Stop,
|
|
|
- activity: resolvedActorRef
|
|
|
- };
|
|
|
- return actionObject;
|
|
|
-}
|
|
|
-var assign2 = function(assignment) {
|
|
|
- return {
|
|
|
- type: assign,
|
|
|
- assignment
|
|
|
- };
|
|
|
-};
|
|
|
-function isActionObject(action) {
|
|
|
- return typeof action === "object" && "type" in action;
|
|
|
-}
|
|
|
-function after2(delayRef, id) {
|
|
|
- var idSuffix = id ? "#".concat(id) : "";
|
|
|
- return "".concat(ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
|
|
|
-}
|
|
|
-function done(id, data) {
|
|
|
- var type = "".concat(ActionTypes.DoneState, ".").concat(id);
|
|
|
- var eventObject = {
|
|
|
- type,
|
|
|
- data
|
|
|
- };
|
|
|
- eventObject.toString = function() {
|
|
|
- return type;
|
|
|
- };
|
|
|
- return eventObject;
|
|
|
-}
|
|
|
-function doneInvoke(id, data) {
|
|
|
- var type = "".concat(ActionTypes.DoneInvoke, ".").concat(id);
|
|
|
- var eventObject = {
|
|
|
- type,
|
|
|
- data
|
|
|
- };
|
|
|
- eventObject.toString = function() {
|
|
|
- return type;
|
|
|
- };
|
|
|
- return eventObject;
|
|
|
-}
|
|
|
-function error2(id, data) {
|
|
|
- var type = "".concat(ActionTypes.ErrorPlatform, ".").concat(id);
|
|
|
- var eventObject = {
|
|
|
- type,
|
|
|
- data
|
|
|
- };
|
|
|
- eventObject.toString = function() {
|
|
|
- return type;
|
|
|
- };
|
|
|
- return eventObject;
|
|
|
-}
|
|
|
-function pure2(getActions) {
|
|
|
- return {
|
|
|
- type: ActionTypes.Pure,
|
|
|
- get: getActions
|
|
|
- };
|
|
|
-}
|
|
|
-function forwardTo(target, options) {
|
|
|
- if (!IS_PRODUCTION && (!target || typeof target === "function")) {
|
|
|
- var originalTarget_1 = target;
|
|
|
- target = function() {
|
|
|
- var args = [];
|
|
|
- for(var _i = 0; _i < arguments.length; _i++){
|
|
|
- args[_i] = arguments[_i];
|
|
|
- }
|
|
|
- var resolvedTarget = typeof originalTarget_1 === "function" ? originalTarget_1.apply(void 0, __spreadArray([], __read(args), false)) : originalTarget_1;
|
|
|
- if (!resolvedTarget) {
|
|
|
- throw new Error("Attempted to forward event to undefined actor. This risks an infinite loop in the sender.");
|
|
|
- }
|
|
|
- return resolvedTarget;
|
|
|
- };
|
|
|
- }
|
|
|
- return send2(function(_, event2) {
|
|
|
- return event2;
|
|
|
- }, __assign(__assign({}, options), {
|
|
|
- to: target
|
|
|
- }));
|
|
|
-}
|
|
|
-function escalate(errorData, options) {
|
|
|
- return sendParent(function(context, event2, meta) {
|
|
|
- return {
|
|
|
- type: error,
|
|
|
- data: isFunction(errorData) ? errorData(context, event2, meta) : errorData
|
|
|
- };
|
|
|
- }, __assign(__assign({}, options), {
|
|
|
- to: SpecialTargets.Parent
|
|
|
- }));
|
|
|
-}
|
|
|
-function choose2(conds) {
|
|
|
- return {
|
|
|
- type: ActionTypes.Choose,
|
|
|
- conds
|
|
|
- };
|
|
|
-}
|
|
|
-var pluckAssigns = function(actionBlocks) {
|
|
|
- var e_1, _a2;
|
|
|
- var assignActions = [];
|
|
|
- try {
|
|
|
- for(var actionBlocks_1 = __values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()){
|
|
|
- var block = actionBlocks_1_1.value;
|
|
|
- var i = 0;
|
|
|
- while(i < block.actions.length){
|
|
|
- if (block.actions[i].type === assign) {
|
|
|
- assignActions.push(block.actions[i]);
|
|
|
- block.actions.splice(i, 1);
|
|
|
- continue;
|
|
|
- }
|
|
|
- i++;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a2 = actionBlocks_1.return)) _a2.call(actionBlocks_1);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return assignActions;
|
|
|
-};
|
|
|
-function resolveActions(machine, currentState, currentContext, _event, actionBlocks, predictableExec, preserveActionOrder) {
|
|
|
- if (preserveActionOrder === void 0) {
|
|
|
- preserveActionOrder = false;
|
|
|
- }
|
|
|
- var assignActions = preserveActionOrder ? [] : pluckAssigns(actionBlocks);
|
|
|
- var updatedContext = assignActions.length ? updateContext(currentContext, _event, assignActions, currentState) : currentContext;
|
|
|
- var preservedContexts = preserveActionOrder ? [
|
|
|
- currentContext
|
|
|
- ] : void 0;
|
|
|
- var deferredToBlockEnd = [];
|
|
|
- function handleAction(blockType, actionObject) {
|
|
|
- var _a2;
|
|
|
- switch(actionObject.type){
|
|
|
- case raise:
|
|
|
- {
|
|
|
- var raisedAction = resolveRaise(actionObject, updatedContext, _event, machine.options.delays);
|
|
|
- if (predictableExec && typeof raisedAction.delay === "number") {
|
|
|
- predictableExec(raisedAction, updatedContext, _event);
|
|
|
- }
|
|
|
- return raisedAction;
|
|
|
- }
|
|
|
- case send:
|
|
|
- var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays);
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- var configuredDelay = actionObject.delay;
|
|
|
- warn(!isString(configuredDelay) || typeof sendAction.delay === "number", "No delay reference for delay expression '".concat(configuredDelay, "' was found on machine '").concat(machine.id, "'"));
|
|
|
- }
|
|
|
- if (predictableExec && sendAction.to !== SpecialTargets.Internal) {
|
|
|
- if (blockType === "entry") {
|
|
|
- deferredToBlockEnd.push(sendAction);
|
|
|
- } else {
|
|
|
- predictableExec(sendAction, updatedContext, _event);
|
|
|
- }
|
|
|
- }
|
|
|
- return sendAction;
|
|
|
- case log:
|
|
|
- {
|
|
|
- var resolved = resolveLog(actionObject, updatedContext, _event);
|
|
|
- predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
|
|
|
- return resolved;
|
|
|
- }
|
|
|
- case choose:
|
|
|
- {
|
|
|
- var chooseAction = actionObject;
|
|
|
- var matchedActions = (_a2 = chooseAction.conds.find(function(condition) {
|
|
|
- var guard = toGuard(condition.cond, machine.options.guards);
|
|
|
- return !guard || evaluateGuard(machine, guard, updatedContext, _event, !predictableExec ? currentState : void 0);
|
|
|
- })) === null || _a2 === void 0 ? void 0 : _a2.actions;
|
|
|
- if (!matchedActions) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- var _b = __read(resolveActions(machine, currentState, updatedContext, _event, [
|
|
|
- {
|
|
|
- type: blockType,
|
|
|
- actions: toActionObjects(toArray(matchedActions), machine.options.actions)
|
|
|
- }
|
|
|
- ], predictableExec, preserveActionOrder), 2), resolvedActionsFromChoose = _b[0], resolvedContextFromChoose = _b[1];
|
|
|
- updatedContext = resolvedContextFromChoose;
|
|
|
- preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
|
|
|
- return resolvedActionsFromChoose;
|
|
|
- }
|
|
|
- case pure:
|
|
|
- {
|
|
|
- var matchedActions = actionObject.get(updatedContext, _event.data);
|
|
|
- if (!matchedActions) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- var _c = __read(resolveActions(machine, currentState, updatedContext, _event, [
|
|
|
- {
|
|
|
- type: blockType,
|
|
|
- actions: toActionObjects(toArray(matchedActions), machine.options.actions)
|
|
|
- }
|
|
|
- ], predictableExec, preserveActionOrder), 2), resolvedActionsFromPure = _c[0], resolvedContext = _c[1];
|
|
|
- updatedContext = resolvedContext;
|
|
|
- preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
|
|
|
- return resolvedActionsFromPure;
|
|
|
- }
|
|
|
- case stop:
|
|
|
- {
|
|
|
- var resolved = resolveStop(actionObject, updatedContext, _event);
|
|
|
- predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, currentContext, _event);
|
|
|
- return resolved;
|
|
|
- }
|
|
|
- case assign:
|
|
|
- {
|
|
|
- updatedContext = updateContext(updatedContext, _event, [
|
|
|
- actionObject
|
|
|
- ], !predictableExec ? currentState : void 0);
|
|
|
- preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
|
|
|
- break;
|
|
|
- }
|
|
|
- default:
|
|
|
- var resolvedActionObject = toActionObject(actionObject, machine.options.actions);
|
|
|
- var exec_1 = resolvedActionObject.exec;
|
|
|
- if (predictableExec) {
|
|
|
- predictableExec(resolvedActionObject, updatedContext, _event);
|
|
|
- } else if (exec_1 && preservedContexts) {
|
|
|
- var contextIndex_1 = preservedContexts.length - 1;
|
|
|
- var wrapped = __assign(__assign({}, resolvedActionObject), {
|
|
|
- exec: function(_ctx) {
|
|
|
- var args = [];
|
|
|
- for(var _i = 1; _i < arguments.length; _i++){
|
|
|
- args[_i - 1] = arguments[_i];
|
|
|
- }
|
|
|
- exec_1.apply(void 0, __spreadArray([
|
|
|
- preservedContexts[contextIndex_1]
|
|
|
- ], __read(args), false));
|
|
|
- }
|
|
|
- });
|
|
|
- resolvedActionObject = wrapped;
|
|
|
- }
|
|
|
- return resolvedActionObject;
|
|
|
- }
|
|
|
- }
|
|
|
- function processBlock(block) {
|
|
|
- var e_2, _a2;
|
|
|
- var resolvedActions2 = [];
|
|
|
- try {
|
|
|
- for(var _b = __values(block.actions), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var action = _c.value;
|
|
|
- var resolved = handleAction(block.type, action);
|
|
|
- if (resolved) {
|
|
|
- resolvedActions2 = resolvedActions2.concat(resolved);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_2_1) {
|
|
|
- e_2 = {
|
|
|
- error: e_2_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_2) throw e_2.error;
|
|
|
- }
|
|
|
- }
|
|
|
- deferredToBlockEnd.forEach(function(action2) {
|
|
|
- predictableExec(action2, updatedContext, _event);
|
|
|
- });
|
|
|
- deferredToBlockEnd.length = 0;
|
|
|
- return resolvedActions2;
|
|
|
- }
|
|
|
- var resolvedActions = flatten(actionBlocks.map(processBlock));
|
|
|
- return [
|
|
|
- resolvedActions,
|
|
|
- updatedContext
|
|
|
- ];
|
|
|
-}
|
|
|
-// node_modules/xstate/es/serviceScope.js
|
|
|
-var serviceStack = [];
|
|
|
-var provide = function(service, fn) {
|
|
|
- serviceStack.push(service);
|
|
|
- var result = fn(service);
|
|
|
- serviceStack.pop();
|
|
|
- return result;
|
|
|
-};
|
|
|
-var consume = function(fn) {
|
|
|
- return fn(serviceStack[serviceStack.length - 1]);
|
|
|
-};
|
|
|
-// node_modules/xstate/es/Actor.js
|
|
|
-function createNullActor(id) {
|
|
|
- var _a2;
|
|
|
- return _a2 = {
|
|
|
- id,
|
|
|
- send: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- subscribe: function() {
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- };
|
|
|
- },
|
|
|
- getSnapshot: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- toJSON: function() {
|
|
|
- return {
|
|
|
- id
|
|
|
- };
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2;
|
|
|
-}
|
|
|
-function createInvocableActor(invokeDefinition, machine, context, _event) {
|
|
|
- var _a2;
|
|
|
- var invokeSrc = toInvokeSource(invokeDefinition.src);
|
|
|
- var serviceCreator = (_a2 = machine === null || machine === void 0 ? void 0 : machine.options.services) === null || _a2 === void 0 ? void 0 : _a2[invokeSrc.type];
|
|
|
- var resolvedData = invokeDefinition.data ? mapContext(invokeDefinition.data, context, _event) : void 0;
|
|
|
- var tempActor = serviceCreator ? createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData) : createNullActor(invokeDefinition.id);
|
|
|
- tempActor.meta = invokeDefinition;
|
|
|
- return tempActor;
|
|
|
-}
|
|
|
-function createDeferredActor(entity, id, data) {
|
|
|
- var tempActor = createNullActor(id);
|
|
|
- tempActor.deferred = true;
|
|
|
- if (isMachine(entity)) {
|
|
|
- var initialState_1 = tempActor.state = provide(void 0, function() {
|
|
|
- return (data ? entity.withContext(data) : entity).initialState;
|
|
|
- });
|
|
|
- tempActor.getSnapshot = function() {
|
|
|
- return initialState_1;
|
|
|
- };
|
|
|
- }
|
|
|
- return tempActor;
|
|
|
-}
|
|
|
-function isActor2(item) {
|
|
|
- try {
|
|
|
- return typeof item.send === "function";
|
|
|
- } catch (e) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-}
|
|
|
-function isSpawnedActor(item) {
|
|
|
- return isActor2(item) && "id" in item;
|
|
|
-}
|
|
|
-function toActorRef(actorRefLike) {
|
|
|
- var _a2;
|
|
|
- return __assign((_a2 = {
|
|
|
- subscribe: function() {
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- };
|
|
|
- },
|
|
|
- id: "anonymous",
|
|
|
- getSnapshot: function() {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2), actorRefLike);
|
|
|
-}
|
|
|
-// node_modules/xstate/es/stateUtils.js
|
|
|
-var isLeafNode = function(stateNode) {
|
|
|
- return stateNode.type === "atomic" || stateNode.type === "final";
|
|
|
-};
|
|
|
-function getAllChildren(stateNode) {
|
|
|
- return Object.keys(stateNode.states).map(function(key) {
|
|
|
- return stateNode.states[key];
|
|
|
- });
|
|
|
-}
|
|
|
-function getChildren(stateNode) {
|
|
|
- return getAllChildren(stateNode).filter(function(sn) {
|
|
|
- return sn.type !== "history";
|
|
|
- });
|
|
|
-}
|
|
|
-function getAllStateNodes(stateNode) {
|
|
|
- var stateNodes = [
|
|
|
- stateNode
|
|
|
- ];
|
|
|
- if (isLeafNode(stateNode)) {
|
|
|
- return stateNodes;
|
|
|
- }
|
|
|
- return stateNodes.concat(flatten(getChildren(stateNode).map(getAllStateNodes)));
|
|
|
-}
|
|
|
-function getConfiguration(prevStateNodes, stateNodes) {
|
|
|
- var e_1, _a2, e_2, _b, e_3, _c, e_4, _d;
|
|
|
- var prevConfiguration = new Set(prevStateNodes);
|
|
|
- var prevAdjList = getAdjList(prevConfiguration);
|
|
|
- var configuration = new Set(stateNodes);
|
|
|
- try {
|
|
|
- for(var configuration_1 = __values(configuration), configuration_1_1 = configuration_1.next(); !configuration_1_1.done; configuration_1_1 = configuration_1.next()){
|
|
|
- var s = configuration_1_1.value;
|
|
|
- var m = s.parent;
|
|
|
- while(m && !configuration.has(m)){
|
|
|
- configuration.add(m);
|
|
|
- m = m.parent;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (configuration_1_1 && !configuration_1_1.done && (_a2 = configuration_1.return)) _a2.call(configuration_1);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- var adjList = getAdjList(configuration);
|
|
|
- try {
|
|
|
- for(var configuration_2 = __values(configuration), configuration_2_1 = configuration_2.next(); !configuration_2_1.done; configuration_2_1 = configuration_2.next()){
|
|
|
- var s = configuration_2_1.value;
|
|
|
- if (s.type === "compound" && (!adjList.get(s) || !adjList.get(s).length)) {
|
|
|
- if (prevAdjList.get(s)) {
|
|
|
- prevAdjList.get(s).forEach(function(sn) {
|
|
|
- return configuration.add(sn);
|
|
|
- });
|
|
|
- } else {
|
|
|
- s.initialStateNodes.forEach(function(sn) {
|
|
|
- return configuration.add(sn);
|
|
|
- });
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (s.type === "parallel") {
|
|
|
- try {
|
|
|
- for(var _e = (e_3 = void 0, __values(getChildren(s))), _f = _e.next(); !_f.done; _f = _e.next()){
|
|
|
- var child = _f.value;
|
|
|
- if (!configuration.has(child)) {
|
|
|
- configuration.add(child);
|
|
|
- if (prevAdjList.get(child)) {
|
|
|
- prevAdjList.get(child).forEach(function(sn) {
|
|
|
- return configuration.add(sn);
|
|
|
- });
|
|
|
- } else {
|
|
|
- child.initialStateNodes.forEach(function(sn) {
|
|
|
- return configuration.add(sn);
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_3_1) {
|
|
|
- e_3 = {
|
|
|
- error: e_3_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
|
|
|
- } finally{
|
|
|
- if (e_3) throw e_3.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_2_1) {
|
|
|
- e_2 = {
|
|
|
- error: e_2_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (configuration_2_1 && !configuration_2_1.done && (_b = configuration_2.return)) _b.call(configuration_2);
|
|
|
- } finally{
|
|
|
- if (e_2) throw e_2.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var configuration_3 = __values(configuration), configuration_3_1 = configuration_3.next(); !configuration_3_1.done; configuration_3_1 = configuration_3.next()){
|
|
|
- var s = configuration_3_1.value;
|
|
|
- var m = s.parent;
|
|
|
- while(m && !configuration.has(m)){
|
|
|
- configuration.add(m);
|
|
|
- m = m.parent;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_4_1) {
|
|
|
- e_4 = {
|
|
|
- error: e_4_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (configuration_3_1 && !configuration_3_1.done && (_d = configuration_3.return)) _d.call(configuration_3);
|
|
|
- } finally{
|
|
|
- if (e_4) throw e_4.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return configuration;
|
|
|
-}
|
|
|
-function getValueFromAdj(baseNode, adjList) {
|
|
|
- var childStateNodes = adjList.get(baseNode);
|
|
|
- if (!childStateNodes) {
|
|
|
- return {};
|
|
|
- }
|
|
|
- if (baseNode.type === "compound") {
|
|
|
- var childStateNode = childStateNodes[0];
|
|
|
- if (childStateNode) {
|
|
|
- if (isLeafNode(childStateNode)) {
|
|
|
- return childStateNode.key;
|
|
|
- }
|
|
|
- } else {
|
|
|
- return {};
|
|
|
- }
|
|
|
- }
|
|
|
- var stateValue = {};
|
|
|
- childStateNodes.forEach(function(csn) {
|
|
|
- stateValue[csn.key] = getValueFromAdj(csn, adjList);
|
|
|
- });
|
|
|
- return stateValue;
|
|
|
-}
|
|
|
-function getAdjList(configuration) {
|
|
|
- var e_5, _a2;
|
|
|
- var adjList = /* @__PURE__ */ new Map();
|
|
|
- try {
|
|
|
- for(var configuration_4 = __values(configuration), configuration_4_1 = configuration_4.next(); !configuration_4_1.done; configuration_4_1 = configuration_4.next()){
|
|
|
- var s = configuration_4_1.value;
|
|
|
- if (!adjList.has(s)) {
|
|
|
- adjList.set(s, []);
|
|
|
- }
|
|
|
- if (s.parent) {
|
|
|
- if (!adjList.has(s.parent)) {
|
|
|
- adjList.set(s.parent, []);
|
|
|
- }
|
|
|
- adjList.get(s.parent).push(s);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_5_1) {
|
|
|
- e_5 = {
|
|
|
- error: e_5_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (configuration_4_1 && !configuration_4_1.done && (_a2 = configuration_4.return)) _a2.call(configuration_4);
|
|
|
- } finally{
|
|
|
- if (e_5) throw e_5.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return adjList;
|
|
|
-}
|
|
|
-function getValue(rootNode, configuration) {
|
|
|
- var config = getConfiguration([
|
|
|
- rootNode
|
|
|
- ], configuration);
|
|
|
- return getValueFromAdj(rootNode, getAdjList(config));
|
|
|
-}
|
|
|
-function has(iterable, item) {
|
|
|
- if (Array.isArray(iterable)) {
|
|
|
- return iterable.some(function(member) {
|
|
|
- return member === item;
|
|
|
- });
|
|
|
- }
|
|
|
- if (iterable instanceof Set) {
|
|
|
- return iterable.has(item);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function nextEvents(configuration) {
|
|
|
- return __spreadArray([], __read(new Set(flatten(__spreadArray([], __read(configuration.map(function(sn) {
|
|
|
- return sn.ownEvents;
|
|
|
- })), false)))), false);
|
|
|
-}
|
|
|
-function isInFinalState(configuration, stateNode) {
|
|
|
- if (stateNode.type === "compound") {
|
|
|
- return getChildren(stateNode).some(function(s) {
|
|
|
- return s.type === "final" && has(configuration, s);
|
|
|
- });
|
|
|
- }
|
|
|
- if (stateNode.type === "parallel") {
|
|
|
- return getChildren(stateNode).every(function(sn) {
|
|
|
- return isInFinalState(configuration, sn);
|
|
|
- });
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function getMeta(configuration) {
|
|
|
- if (configuration === void 0) {
|
|
|
- configuration = [];
|
|
|
- }
|
|
|
- return configuration.reduce(function(acc, stateNode) {
|
|
|
- if (stateNode.meta !== void 0) {
|
|
|
- acc[stateNode.id] = stateNode.meta;
|
|
|
- }
|
|
|
- return acc;
|
|
|
- }, {});
|
|
|
-}
|
|
|
-function getTagsFromConfiguration(configuration) {
|
|
|
- return new Set(flatten(configuration.map(function(sn) {
|
|
|
- return sn.tags;
|
|
|
- })));
|
|
|
-}
|
|
|
-// node_modules/xstate/es/State.js
|
|
|
-function stateValuesEqual(a, b) {
|
|
|
- if (a === b) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (a === void 0 || b === void 0) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (isString(a) || isString(b)) {
|
|
|
- return a === b;
|
|
|
- }
|
|
|
- var aKeys = Object.keys(a);
|
|
|
- var bKeys = Object.keys(b);
|
|
|
- return aKeys.length === bKeys.length && aKeys.every(function(key) {
|
|
|
- return stateValuesEqual(a[key], b[key]);
|
|
|
- });
|
|
|
-}
|
|
|
-function isStateConfig(state) {
|
|
|
- if (typeof state !== "object" || state === null) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return "value" in state && "_event" in state;
|
|
|
-}
|
|
|
-function bindActionToState(action, state) {
|
|
|
- var exec = action.exec;
|
|
|
- var boundAction = __assign(__assign({}, action), {
|
|
|
- exec: exec !== void 0 ? function() {
|
|
|
- return exec(state.context, state.event, {
|
|
|
- action,
|
|
|
- state,
|
|
|
- _event: state._event
|
|
|
- });
|
|
|
- } : void 0
|
|
|
- });
|
|
|
- return boundAction;
|
|
|
-}
|
|
|
-var State = function() {
|
|
|
- function State2(config) {
|
|
|
- var _this = this;
|
|
|
- var _a2;
|
|
|
- this.actions = [];
|
|
|
- this.activities = EMPTY_ACTIVITY_MAP;
|
|
|
- this.meta = {};
|
|
|
- this.events = [];
|
|
|
- this.value = config.value;
|
|
|
- this.context = config.context;
|
|
|
- this._event = config._event;
|
|
|
- this._sessionid = config._sessionid;
|
|
|
- this.event = this._event.data;
|
|
|
- this.historyValue = config.historyValue;
|
|
|
- this.history = config.history;
|
|
|
- this.actions = config.actions || [];
|
|
|
- this.activities = config.activities || EMPTY_ACTIVITY_MAP;
|
|
|
- this.meta = getMeta(config.configuration);
|
|
|
- this.events = config.events || [];
|
|
|
- this.matches = this.matches.bind(this);
|
|
|
- this.toStrings = this.toStrings.bind(this);
|
|
|
- this.configuration = config.configuration;
|
|
|
- this.transitions = config.transitions;
|
|
|
- this.children = config.children;
|
|
|
- this.done = !!config.done;
|
|
|
- this.tags = (_a2 = Array.isArray(config.tags) ? new Set(config.tags) : config.tags) !== null && _a2 !== void 0 ? _a2 : /* @__PURE__ */ new Set();
|
|
|
- this.machine = config.machine;
|
|
|
- Object.defineProperty(this, "nextEvents", {
|
|
|
- get: function() {
|
|
|
- return nextEvents(_this.configuration);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- State2.from = function(stateValue, context) {
|
|
|
- if (stateValue instanceof State2) {
|
|
|
- if (stateValue.context !== context) {
|
|
|
- return new State2({
|
|
|
- value: stateValue.value,
|
|
|
- context,
|
|
|
- _event: stateValue._event,
|
|
|
- _sessionid: null,
|
|
|
- historyValue: stateValue.historyValue,
|
|
|
- history: stateValue.history,
|
|
|
- actions: [],
|
|
|
- activities: stateValue.activities,
|
|
|
- meta: {},
|
|
|
- events: [],
|
|
|
- configuration: [],
|
|
|
- transitions: [],
|
|
|
- children: {}
|
|
|
- });
|
|
|
- }
|
|
|
- return stateValue;
|
|
|
- }
|
|
|
- var _event = initEvent;
|
|
|
- return new State2({
|
|
|
- value: stateValue,
|
|
|
- context,
|
|
|
- _event,
|
|
|
- _sessionid: null,
|
|
|
- historyValue: void 0,
|
|
|
- history: void 0,
|
|
|
- actions: [],
|
|
|
- activities: void 0,
|
|
|
- meta: void 0,
|
|
|
- events: [],
|
|
|
- configuration: [],
|
|
|
- transitions: [],
|
|
|
- children: {}
|
|
|
- });
|
|
|
- };
|
|
|
- State2.create = function(config) {
|
|
|
- return new State2(config);
|
|
|
- };
|
|
|
- State2.inert = function(stateValue, context) {
|
|
|
- if (stateValue instanceof State2) {
|
|
|
- if (!stateValue.actions.length) {
|
|
|
- return stateValue;
|
|
|
- }
|
|
|
- var _event = initEvent;
|
|
|
- return new State2({
|
|
|
- value: stateValue.value,
|
|
|
- context,
|
|
|
- _event,
|
|
|
- _sessionid: null,
|
|
|
- historyValue: stateValue.historyValue,
|
|
|
- history: stateValue.history,
|
|
|
- activities: stateValue.activities,
|
|
|
- configuration: stateValue.configuration,
|
|
|
- transitions: [],
|
|
|
- children: {}
|
|
|
- });
|
|
|
- }
|
|
|
- return State2.from(stateValue, context);
|
|
|
- };
|
|
|
- State2.prototype.toStrings = function(stateValue, delimiter) {
|
|
|
- var _this = this;
|
|
|
- if (stateValue === void 0) {
|
|
|
- stateValue = this.value;
|
|
|
- }
|
|
|
- if (delimiter === void 0) {
|
|
|
- delimiter = ".";
|
|
|
- }
|
|
|
- if (isString(stateValue)) {
|
|
|
- return [
|
|
|
- stateValue
|
|
|
- ];
|
|
|
- }
|
|
|
- var valueKeys = Object.keys(stateValue);
|
|
|
- return valueKeys.concat.apply(valueKeys, __spreadArray([], __read(valueKeys.map(function(key) {
|
|
|
- return _this.toStrings(stateValue[key], delimiter).map(function(s) {
|
|
|
- return key + delimiter + s;
|
|
|
- });
|
|
|
- })), false));
|
|
|
- };
|
|
|
- State2.prototype.toJSON = function() {
|
|
|
- var _a2 = this;
|
|
|
- _a2.configuration;
|
|
|
- _a2.transitions;
|
|
|
- var tags = _a2.tags;
|
|
|
- _a2.machine;
|
|
|
- var jsonValues = __rest(_a2, [
|
|
|
- "configuration",
|
|
|
- "transitions",
|
|
|
- "tags",
|
|
|
- "machine"
|
|
|
- ]);
|
|
|
- return __assign(__assign({}, jsonValues), {
|
|
|
- tags: Array.from(tags)
|
|
|
- });
|
|
|
- };
|
|
|
- State2.prototype.matches = function(parentStateValue) {
|
|
|
- return matchesState(parentStateValue, this.value);
|
|
|
- };
|
|
|
- State2.prototype.hasTag = function(tag) {
|
|
|
- return this.tags.has(tag);
|
|
|
- };
|
|
|
- State2.prototype.can = function(event2) {
|
|
|
- var _a2;
|
|
|
- if (IS_PRODUCTION) {
|
|
|
- warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
|
|
|
- }
|
|
|
- var transitionData = (_a2 = this.machine) === null || _a2 === void 0 ? void 0 : _a2.getTransitionData(this, event2);
|
|
|
- return !!(transitionData === null || transitionData === void 0 ? void 0 : transitionData.transitions.length) && transitionData.transitions.some(function(t2) {
|
|
|
- return t2.target !== void 0 || t2.actions.length;
|
|
|
- });
|
|
|
- };
|
|
|
- return State2;
|
|
|
-}();
|
|
|
-// node_modules/xstate/es/scheduler.js
|
|
|
-var defaultOptions = {
|
|
|
- deferEvents: false
|
|
|
-};
|
|
|
-var Scheduler = function() {
|
|
|
- function Scheduler2(options) {
|
|
|
- this.processingEvent = false;
|
|
|
- this.queue = [];
|
|
|
- this.initialized = false;
|
|
|
- this.options = __assign(__assign({}, defaultOptions), options);
|
|
|
- }
|
|
|
- Scheduler2.prototype.initialize = function(callback) {
|
|
|
- this.initialized = true;
|
|
|
- if (callback) {
|
|
|
- if (!this.options.deferEvents) {
|
|
|
- this.schedule(callback);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.process(callback);
|
|
|
- }
|
|
|
- this.flushEvents();
|
|
|
- };
|
|
|
- Scheduler2.prototype.schedule = function(task) {
|
|
|
- if (!this.initialized || this.processingEvent) {
|
|
|
- this.queue.push(task);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.queue.length !== 0) {
|
|
|
- throw new Error("Event queue should be empty when it is not processing events");
|
|
|
- }
|
|
|
- this.process(task);
|
|
|
- this.flushEvents();
|
|
|
- };
|
|
|
- Scheduler2.prototype.clear = function() {
|
|
|
- this.queue = [];
|
|
|
- };
|
|
|
- Scheduler2.prototype.flushEvents = function() {
|
|
|
- var nextCallback = this.queue.shift();
|
|
|
- while(nextCallback){
|
|
|
- this.process(nextCallback);
|
|
|
- nextCallback = this.queue.shift();
|
|
|
- }
|
|
|
- };
|
|
|
- Scheduler2.prototype.process = function(callback) {
|
|
|
- this.processingEvent = true;
|
|
|
- try {
|
|
|
- callback();
|
|
|
- } catch (e) {
|
|
|
- this.clear();
|
|
|
- throw e;
|
|
|
- } finally{
|
|
|
- this.processingEvent = false;
|
|
|
- }
|
|
|
- };
|
|
|
- return Scheduler2;
|
|
|
-}();
|
|
|
-// node_modules/xstate/es/registry.js
|
|
|
-var children = /* @__PURE__ */ new Map();
|
|
|
-var sessionIdIndex = 0;
|
|
|
-var registry = {
|
|
|
- bookId: function() {
|
|
|
- return "x:".concat(sessionIdIndex++);
|
|
|
- },
|
|
|
- register: function(id, actor) {
|
|
|
- children.set(id, actor);
|
|
|
- return id;
|
|
|
- },
|
|
|
- get: function(id) {
|
|
|
- return children.get(id);
|
|
|
- },
|
|
|
- free: function(id) {
|
|
|
- children.delete(id);
|
|
|
- }
|
|
|
-};
|
|
|
-// node_modules/xstate/es/devTools.js
|
|
|
-function getGlobal() {
|
|
|
- if (typeof globalThis !== "undefined") {
|
|
|
- return globalThis;
|
|
|
- }
|
|
|
- if (typeof self !== "undefined") {
|
|
|
- return self;
|
|
|
- }
|
|
|
- if (typeof window !== "undefined") {
|
|
|
- return window;
|
|
|
- }
|
|
|
- if (typeof __webpack_require__.g !== "undefined") {
|
|
|
- return __webpack_require__.g;
|
|
|
- }
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- console.warn("XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues");
|
|
|
- }
|
|
|
-}
|
|
|
-function getDevTools() {
|
|
|
- var global2 = getGlobal();
|
|
|
- if (global2 && "__xstate__" in global2) {
|
|
|
- return global2.__xstate__;
|
|
|
- }
|
|
|
- return void 0;
|
|
|
-}
|
|
|
-function registerService(service) {
|
|
|
- if (!getGlobal()) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var devTools = getDevTools();
|
|
|
- if (devTools) {
|
|
|
- devTools.register(service);
|
|
|
- }
|
|
|
-}
|
|
|
-// node_modules/xstate/es/behaviors.js
|
|
|
-function spawnBehavior(behavior, options) {
|
|
|
- if (options === void 0) {
|
|
|
- options = {};
|
|
|
- }
|
|
|
- var state = behavior.initialState;
|
|
|
- var observers = /* @__PURE__ */ new Set();
|
|
|
- var mailbox = [];
|
|
|
- var flushing = false;
|
|
|
- var flush = function() {
|
|
|
- if (flushing) {
|
|
|
- return;
|
|
|
- }
|
|
|
- flushing = true;
|
|
|
- while(mailbox.length > 0){
|
|
|
- var event_1 = mailbox.shift();
|
|
|
- state = behavior.transition(state, event_1, actorCtx);
|
|
|
- observers.forEach(function(observer) {
|
|
|
- return observer.next(state);
|
|
|
- });
|
|
|
- }
|
|
|
- flushing = false;
|
|
|
- };
|
|
|
- var actor = toActorRef({
|
|
|
- id: options.id,
|
|
|
- send: function(event2) {
|
|
|
- mailbox.push(event2);
|
|
|
- flush();
|
|
|
- },
|
|
|
- getSnapshot: function() {
|
|
|
- return state;
|
|
|
- },
|
|
|
- subscribe: function(next, handleError, complete) {
|
|
|
- var observer = toObserver(next, handleError, complete);
|
|
|
- observers.add(observer);
|
|
|
- observer.next(state);
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- observers.delete(observer);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- });
|
|
|
- var actorCtx = {
|
|
|
- parent: options.parent,
|
|
|
- self: actor,
|
|
|
- id: options.id || "anonymous",
|
|
|
- observers
|
|
|
- };
|
|
|
- state = behavior.start ? behavior.start(actorCtx) : state;
|
|
|
- return actor;
|
|
|
-}
|
|
|
-// node_modules/xstate/es/interpreter.js
|
|
|
-var DEFAULT_SPAWN_OPTIONS = {
|
|
|
- sync: false,
|
|
|
- autoForward: false
|
|
|
-};
|
|
|
-var InterpreterStatus;
|
|
|
-(function(InterpreterStatus2) {
|
|
|
- InterpreterStatus2[InterpreterStatus2["NotStarted"] = 0] = "NotStarted";
|
|
|
- InterpreterStatus2[InterpreterStatus2["Running"] = 1] = "Running";
|
|
|
- InterpreterStatus2[InterpreterStatus2["Stopped"] = 2] = "Stopped";
|
|
|
-})(InterpreterStatus || (InterpreterStatus = {}));
|
|
|
-var Interpreter = function() {
|
|
|
- function Interpreter2(machine, options) {
|
|
|
- if (options === void 0) {
|
|
|
- options = Interpreter2.defaultOptions;
|
|
|
- }
|
|
|
- var _this = this;
|
|
|
- this.machine = machine;
|
|
|
- this.delayedEventsMap = {};
|
|
|
- this.listeners = /* @__PURE__ */ new Set();
|
|
|
- this.contextListeners = /* @__PURE__ */ new Set();
|
|
|
- this.stopListeners = /* @__PURE__ */ new Set();
|
|
|
- this.doneListeners = /* @__PURE__ */ new Set();
|
|
|
- this.eventListeners = /* @__PURE__ */ new Set();
|
|
|
- this.sendListeners = /* @__PURE__ */ new Set();
|
|
|
- this.initialized = false;
|
|
|
- this.status = InterpreterStatus.NotStarted;
|
|
|
- this.children = /* @__PURE__ */ new Map();
|
|
|
- this.forwardTo = /* @__PURE__ */ new Set();
|
|
|
- this._outgoingQueue = [];
|
|
|
- this.init = this.start;
|
|
|
- this.send = function(event2, payload) {
|
|
|
- if (isArray(event2)) {
|
|
|
- _this.batch(event2);
|
|
|
- return _this.state;
|
|
|
- }
|
|
|
- var _event = toSCXMLEvent(toEventObject(event2, payload));
|
|
|
- if (_this.status === InterpreterStatus.Stopped) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, 'Event "'.concat(_event.name, '" was sent to stopped service "').concat(_this.machine.id, '". This service has already reached its final state, and will not transition.\nEvent: ').concat(JSON.stringify(_event.data)));
|
|
|
- }
|
|
|
- return _this.state;
|
|
|
- }
|
|
|
- if (_this.status !== InterpreterStatus.Running && !_this.options.deferEvents) {
|
|
|
- throw new Error('Event "'.concat(_event.name, '" was sent to uninitialized service "').concat(_this.machine.id, '". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: ').concat(JSON.stringify(_event.data)));
|
|
|
- }
|
|
|
- _this.scheduler.schedule(function() {
|
|
|
- _this.forward(_event);
|
|
|
- var nextState = _this._nextState(_event);
|
|
|
- _this.update(nextState, _event);
|
|
|
- });
|
|
|
- return _this._state;
|
|
|
- };
|
|
|
- this.sendTo = function(event2, to, immediate) {
|
|
|
- var isParent = _this.parent && (to === SpecialTargets.Parent || _this.parent.id === to);
|
|
|
- var target = isParent ? _this.parent : isString(to) ? to === SpecialTargets.Internal ? _this : _this.children.get(to) || registry.get(to) : isActor(to) ? to : void 0;
|
|
|
- if (!target) {
|
|
|
- if (!isParent) {
|
|
|
- throw new Error("Unable to send event to child '".concat(to, "' from service '").concat(_this.id, "'."));
|
|
|
- }
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "Service '".concat(_this.id, "' has no parent: unable to send event ").concat(event2.type));
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if ("machine" in target) {
|
|
|
- if (_this.status !== InterpreterStatus.Stopped || _this.parent !== target || _this.state.done) {
|
|
|
- var scxmlEvent = __assign(__assign({}, event2), {
|
|
|
- name: event2.name === error ? "".concat(error2(_this.id)) : event2.name,
|
|
|
- origin: _this.sessionId
|
|
|
- });
|
|
|
- if (!immediate && _this.machine.config.predictableActionArguments) {
|
|
|
- _this._outgoingQueue.push([
|
|
|
- target,
|
|
|
- scxmlEvent
|
|
|
- ]);
|
|
|
- } else {
|
|
|
- target.send(scxmlEvent);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (!immediate && _this.machine.config.predictableActionArguments) {
|
|
|
- _this._outgoingQueue.push([
|
|
|
- target,
|
|
|
- event2.data
|
|
|
- ]);
|
|
|
- } else {
|
|
|
- target.send(event2.data);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- this._exec = function(action, context, _event, actionFunctionMap) {
|
|
|
- if (actionFunctionMap === void 0) {
|
|
|
- actionFunctionMap = _this.machine.options.actions;
|
|
|
- }
|
|
|
- var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
|
|
|
- var exec = isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
|
|
|
- if (exec) {
|
|
|
- try {
|
|
|
- return exec(context, _event.data, !_this.machine.config.predictableActionArguments ? {
|
|
|
- action,
|
|
|
- state: _this.state,
|
|
|
- _event
|
|
|
- } : {
|
|
|
- action,
|
|
|
- _event
|
|
|
- });
|
|
|
- } catch (err) {
|
|
|
- if (_this.parent) {
|
|
|
- _this.parent.send({
|
|
|
- type: "xstate.error",
|
|
|
- data: err
|
|
|
- });
|
|
|
- }
|
|
|
- throw err;
|
|
|
- }
|
|
|
- }
|
|
|
- switch(action.type){
|
|
|
- case raise:
|
|
|
- {
|
|
|
- var sendAction_1 = action;
|
|
|
- _this.defer(sendAction_1);
|
|
|
- break;
|
|
|
- }
|
|
|
- case send:
|
|
|
- var sendAction = action;
|
|
|
- if (typeof sendAction.delay === "number") {
|
|
|
- _this.defer(sendAction);
|
|
|
- return;
|
|
|
- } else {
|
|
|
- if (sendAction.to) {
|
|
|
- _this.sendTo(sendAction._event, sendAction.to, _event === initEvent);
|
|
|
- } else {
|
|
|
- _this.send(sendAction._event);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case cancel:
|
|
|
- _this.cancel(action.sendId);
|
|
|
- break;
|
|
|
- case start:
|
|
|
- {
|
|
|
- if (_this.status !== InterpreterStatus.Running) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var activity = action.activity;
|
|
|
- if (!_this.machine.config.predictableActionArguments && !_this.state.activities[activity.id || activity.type]) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (activity.type === ActionTypes.Invoke) {
|
|
|
- var invokeSource = toInvokeSource(activity.src);
|
|
|
- var serviceCreator = _this.machine.options.services ? _this.machine.options.services[invokeSource.type] : void 0;
|
|
|
- var id2 = activity.id, data = activity.data;
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(!("forward" in activity), "`forward` property is deprecated (found in invocation of '".concat(activity.src, "' in in machine '").concat(_this.machine.id, "'). ") + "Please use `autoForward` instead.");
|
|
|
- }
|
|
|
- var autoForward = "autoForward" in activity ? activity.autoForward : !!activity.forward;
|
|
|
- if (!serviceCreator) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(_this.machine.id, "'."));
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- var resolvedData = data ? mapContext(data, context, _event) : void 0;
|
|
|
- if (typeof serviceCreator === "string") {
|
|
|
- return;
|
|
|
- }
|
|
|
- var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
|
|
|
- data: resolvedData,
|
|
|
- src: invokeSource,
|
|
|
- meta: activity.meta
|
|
|
- }) : serviceCreator;
|
|
|
- if (!source) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var options2 = void 0;
|
|
|
- if (isMachine(source)) {
|
|
|
- source = resolvedData ? source.withContext(resolvedData) : source;
|
|
|
- options2 = {
|
|
|
- autoForward
|
|
|
- };
|
|
|
- }
|
|
|
- _this.spawn(source, id2, options2);
|
|
|
- } else {
|
|
|
- _this.spawnActivity(activity);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case stop:
|
|
|
- {
|
|
|
- _this.stopChild(action.activity.id);
|
|
|
- break;
|
|
|
- }
|
|
|
- case log:
|
|
|
- var _a2 = action, label = _a2.label, value = _a2.value;
|
|
|
- if (label) {
|
|
|
- _this.logger(label, value);
|
|
|
- } else {
|
|
|
- _this.logger(value);
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "No implementation found for action type '".concat(action.type, "'"));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- };
|
|
|
- var resolvedOptions = __assign(__assign({}, Interpreter2.defaultOptions), options);
|
|
|
- var clock = resolvedOptions.clock, logger = resolvedOptions.logger, parent = resolvedOptions.parent, id = resolvedOptions.id;
|
|
|
- var resolvedId = id !== void 0 ? id : machine.id;
|
|
|
- this.id = resolvedId;
|
|
|
- this.logger = logger;
|
|
|
- this.clock = clock;
|
|
|
- this.parent = parent;
|
|
|
- this.options = resolvedOptions;
|
|
|
- this.scheduler = new Scheduler({
|
|
|
- deferEvents: this.options.deferEvents
|
|
|
- });
|
|
|
- this.sessionId = registry.bookId();
|
|
|
- }
|
|
|
- Object.defineProperty(Interpreter2.prototype, "initialState", {
|
|
|
- get: function() {
|
|
|
- var _this = this;
|
|
|
- if (this._initialState) {
|
|
|
- return this._initialState;
|
|
|
- }
|
|
|
- return provide(this, function() {
|
|
|
- _this._initialState = _this.machine.initialState;
|
|
|
- return _this._initialState;
|
|
|
- });
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(Interpreter2.prototype, "state", {
|
|
|
- get: function() {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(this.status !== InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
|
|
|
- }
|
|
|
- return this._state;
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Interpreter2.prototype.execute = function(state, actionsConfig) {
|
|
|
- var e_1, _a2;
|
|
|
- try {
|
|
|
- for(var _b = __values(state.actions), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var action = _c.value;
|
|
|
- this.exec(action, state, actionsConfig);
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.update = function(state, _event) {
|
|
|
- var e_2, _a2, e_3, _b, e_4, _c, e_5, _d;
|
|
|
- var _this = this;
|
|
|
- state._sessionid = this.sessionId;
|
|
|
- this._state = state;
|
|
|
- if ((!this.machine.config.predictableActionArguments || _event === initEvent) && this.options.execute) {
|
|
|
- this.execute(this.state);
|
|
|
- } else {
|
|
|
- var item = void 0;
|
|
|
- while(item = this._outgoingQueue.shift()){
|
|
|
- item[0].send(item[1]);
|
|
|
- }
|
|
|
- }
|
|
|
- this.children.forEach(function(child) {
|
|
|
- _this.state.children[child.id] = child;
|
|
|
- });
|
|
|
- if (this.devTools) {
|
|
|
- this.devTools.send(_event.data, state);
|
|
|
- }
|
|
|
- if (state.event) {
|
|
|
- try {
|
|
|
- for(var _e = __values(this.eventListeners), _f = _e.next(); !_f.done; _f = _e.next()){
|
|
|
- var listener = _f.value;
|
|
|
- listener(state.event);
|
|
|
- }
|
|
|
- } catch (e_2_1) {
|
|
|
- e_2 = {
|
|
|
- error: e_2_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_f && !_f.done && (_a2 = _e.return)) _a2.call(_e);
|
|
|
- } finally{
|
|
|
- if (e_2) throw e_2.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var _g = __values(this.listeners), _h = _g.next(); !_h.done; _h = _g.next()){
|
|
|
- var listener = _h.value;
|
|
|
- listener(state, state.event);
|
|
|
- }
|
|
|
- } catch (e_3_1) {
|
|
|
- e_3 = {
|
|
|
- error: e_3_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
|
|
|
- } finally{
|
|
|
- if (e_3) throw e_3.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var _j = __values(this.contextListeners), _k = _j.next(); !_k.done; _k = _j.next()){
|
|
|
- var contextListener = _k.value;
|
|
|
- contextListener(this.state.context, this.state.history ? this.state.history.context : void 0);
|
|
|
- }
|
|
|
- } catch (e_4_1) {
|
|
|
- e_4 = {
|
|
|
- error: e_4_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
|
|
|
- } finally{
|
|
|
- if (e_4) throw e_4.error;
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.state.done) {
|
|
|
- var finalChildStateNode = state.configuration.find(function(sn) {
|
|
|
- return sn.type === "final" && sn.parent === _this.machine;
|
|
|
- });
|
|
|
- var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, state.context, _event) : void 0;
|
|
|
- this._doneEvent = doneInvoke(this.id, doneData);
|
|
|
- try {
|
|
|
- for(var _l = __values(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()){
|
|
|
- var listener = _m.value;
|
|
|
- listener(this._doneEvent);
|
|
|
- }
|
|
|
- } catch (e_5_1) {
|
|
|
- e_5 = {
|
|
|
- error: e_5_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
|
|
|
- } finally{
|
|
|
- if (e_5) throw e_5.error;
|
|
|
- }
|
|
|
- }
|
|
|
- this._stop();
|
|
|
- this._stopChildren();
|
|
|
- registry.free(this.sessionId);
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.onTransition = function(listener) {
|
|
|
- this.listeners.add(listener);
|
|
|
- if (this.status === InterpreterStatus.Running) {
|
|
|
- listener(this.state, this.state.event);
|
|
|
- }
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.subscribe = function(nextListenerOrObserver, _, completeListener) {
|
|
|
- var _this = this;
|
|
|
- var observer = toObserver(nextListenerOrObserver, _, completeListener);
|
|
|
- this.listeners.add(observer.next);
|
|
|
- if (this.status !== InterpreterStatus.NotStarted) {
|
|
|
- observer.next(this.state);
|
|
|
- }
|
|
|
- var completeOnce = function() {
|
|
|
- _this.doneListeners.delete(completeOnce);
|
|
|
- _this.stopListeners.delete(completeOnce);
|
|
|
- observer.complete();
|
|
|
- };
|
|
|
- if (this.status === InterpreterStatus.Stopped) {
|
|
|
- observer.complete();
|
|
|
- } else {
|
|
|
- this.onDone(completeOnce);
|
|
|
- this.onStop(completeOnce);
|
|
|
- }
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- _this.listeners.delete(observer.next);
|
|
|
- _this.doneListeners.delete(completeOnce);
|
|
|
- _this.stopListeners.delete(completeOnce);
|
|
|
- }
|
|
|
- };
|
|
|
- };
|
|
|
- Interpreter2.prototype.onEvent = function(listener) {
|
|
|
- this.eventListeners.add(listener);
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.onSend = function(listener) {
|
|
|
- this.sendListeners.add(listener);
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.onChange = function(listener) {
|
|
|
- this.contextListeners.add(listener);
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.onStop = function(listener) {
|
|
|
- this.stopListeners.add(listener);
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.onDone = function(listener) {
|
|
|
- if (this.status === InterpreterStatus.Stopped && this._doneEvent) {
|
|
|
- listener(this._doneEvent);
|
|
|
- } else {
|
|
|
- this.doneListeners.add(listener);
|
|
|
- }
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.off = function(listener) {
|
|
|
- this.listeners.delete(listener);
|
|
|
- this.eventListeners.delete(listener);
|
|
|
- this.sendListeners.delete(listener);
|
|
|
- this.stopListeners.delete(listener);
|
|
|
- this.doneListeners.delete(listener);
|
|
|
- this.contextListeners.delete(listener);
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.start = function(initialState) {
|
|
|
- var _this = this;
|
|
|
- if (this.status === InterpreterStatus.Running) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- this.machine._init();
|
|
|
- registry.register(this.sessionId, this);
|
|
|
- this.initialized = true;
|
|
|
- this.status = InterpreterStatus.Running;
|
|
|
- var resolvedState = initialState === void 0 ? this.initialState : provide(this, function() {
|
|
|
- return isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.from(initialState, _this.machine.context));
|
|
|
- });
|
|
|
- if (this.options.devTools) {
|
|
|
- this.attachDev();
|
|
|
- }
|
|
|
- this.scheduler.initialize(function() {
|
|
|
- _this.update(resolvedState, initEvent);
|
|
|
- });
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype._stopChildren = function() {
|
|
|
- this.children.forEach(function(child) {
|
|
|
- if (isFunction(child.stop)) {
|
|
|
- child.stop();
|
|
|
- }
|
|
|
- });
|
|
|
- this.children.clear();
|
|
|
- };
|
|
|
- Interpreter2.prototype._stop = function() {
|
|
|
- var e_6, _a2, e_7, _b, e_8, _c, e_9, _d, e_10, _e;
|
|
|
- try {
|
|
|
- for(var _f = __values(this.listeners), _g = _f.next(); !_g.done; _g = _f.next()){
|
|
|
- var listener = _g.value;
|
|
|
- this.listeners.delete(listener);
|
|
|
- }
|
|
|
- } catch (e_6_1) {
|
|
|
- e_6 = {
|
|
|
- error: e_6_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_g && !_g.done && (_a2 = _f.return)) _a2.call(_f);
|
|
|
- } finally{
|
|
|
- if (e_6) throw e_6.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var _h = __values(this.stopListeners), _j = _h.next(); !_j.done; _j = _h.next()){
|
|
|
- var listener = _j.value;
|
|
|
- listener();
|
|
|
- this.stopListeners.delete(listener);
|
|
|
- }
|
|
|
- } catch (e_7_1) {
|
|
|
- e_7 = {
|
|
|
- error: e_7_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
|
|
|
- } finally{
|
|
|
- if (e_7) throw e_7.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var _k = __values(this.contextListeners), _l = _k.next(); !_l.done; _l = _k.next()){
|
|
|
- var listener = _l.value;
|
|
|
- this.contextListeners.delete(listener);
|
|
|
- }
|
|
|
- } catch (e_8_1) {
|
|
|
- e_8 = {
|
|
|
- error: e_8_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
|
|
|
- } finally{
|
|
|
- if (e_8) throw e_8.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var _m = __values(this.doneListeners), _o = _m.next(); !_o.done; _o = _m.next()){
|
|
|
- var listener = _o.value;
|
|
|
- this.doneListeners.delete(listener);
|
|
|
- }
|
|
|
- } catch (e_9_1) {
|
|
|
- e_9 = {
|
|
|
- error: e_9_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
|
|
|
- } finally{
|
|
|
- if (e_9) throw e_9.error;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.initialized) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- this.initialized = false;
|
|
|
- this.status = InterpreterStatus.Stopped;
|
|
|
- this._initialState = void 0;
|
|
|
- try {
|
|
|
- for(var _p = __values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()){
|
|
|
- var key = _q.value;
|
|
|
- this.clock.clearTimeout(this.delayedEventsMap[key]);
|
|
|
- }
|
|
|
- } catch (e_10_1) {
|
|
|
- e_10 = {
|
|
|
- error: e_10_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
|
|
|
- } finally{
|
|
|
- if (e_10) throw e_10.error;
|
|
|
- }
|
|
|
- }
|
|
|
- this.scheduler.clear();
|
|
|
- this.scheduler = new Scheduler({
|
|
|
- deferEvents: this.options.deferEvents
|
|
|
- });
|
|
|
- };
|
|
|
- Interpreter2.prototype.stop = function() {
|
|
|
- var _this = this;
|
|
|
- var scheduler = this.scheduler;
|
|
|
- this._stop();
|
|
|
- scheduler.schedule(function() {
|
|
|
- var _event = toSCXMLEvent({
|
|
|
- type: "xstate.stop"
|
|
|
- });
|
|
|
- var nextState = provide(_this, function() {
|
|
|
- var exitActions = flatten(__spreadArray([], __read(_this.state.configuration), false).sort(function(a, b) {
|
|
|
- return b.order - a.order;
|
|
|
- }).map(function(stateNode) {
|
|
|
- return toActionObjects(stateNode.onExit, _this.machine.options.actions);
|
|
|
- }));
|
|
|
- var _a2 = __read(resolveActions(_this.machine, _this.state, _this.state.context, _event, [
|
|
|
- {
|
|
|
- type: "exit",
|
|
|
- actions: exitActions
|
|
|
- }
|
|
|
- ], _this.machine.config.predictableActionArguments ? _this._exec : void 0, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2), resolvedActions = _a2[0], updatedContext = _a2[1];
|
|
|
- var newState = new State({
|
|
|
- value: _this.state.value,
|
|
|
- context: updatedContext,
|
|
|
- _event,
|
|
|
- _sessionid: _this.sessionId,
|
|
|
- historyValue: void 0,
|
|
|
- history: _this.state,
|
|
|
- actions: resolvedActions.filter(function(action) {
|
|
|
- return !isRaisableAction(action);
|
|
|
- }),
|
|
|
- activities: {},
|
|
|
- events: [],
|
|
|
- configuration: [],
|
|
|
- transitions: [],
|
|
|
- children: {},
|
|
|
- done: _this.state.done,
|
|
|
- tags: _this.state.tags,
|
|
|
- machine: _this.machine
|
|
|
- });
|
|
|
- newState.changed = true;
|
|
|
- return newState;
|
|
|
- });
|
|
|
- _this.update(nextState, _event);
|
|
|
- _this._stopChildren();
|
|
|
- registry.free(_this.sessionId);
|
|
|
- });
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.batch = function(events) {
|
|
|
- var _this = this;
|
|
|
- if (this.status === InterpreterStatus.NotStarted && this.options.deferEvents) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "".concat(events.length, ' event(s) were sent to uninitialized service "').concat(this.machine.id, '" and are deferred. Make sure .start() is called for this service.\nEvent: ').concat(JSON.stringify(event)));
|
|
|
- }
|
|
|
- } else if (this.status !== InterpreterStatus.Running) {
|
|
|
- throw new Error("".concat(events.length, ' event(s) were sent to uninitialized service "').concat(this.machine.id, '". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.'));
|
|
|
- }
|
|
|
- if (!events.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var exec = !!this.machine.config.predictableActionArguments && this._exec;
|
|
|
- this.scheduler.schedule(function() {
|
|
|
- var e_11, _a2;
|
|
|
- var nextState = _this.state;
|
|
|
- var batchChanged = false;
|
|
|
- var batchedActions = [];
|
|
|
- var _loop_1 = function(event_12) {
|
|
|
- var _event = toSCXMLEvent(event_12);
|
|
|
- _this.forward(_event);
|
|
|
- nextState = provide(_this, function() {
|
|
|
- return _this.machine.transition(nextState, _event, void 0, exec || void 0);
|
|
|
- });
|
|
|
- batchedActions.push.apply(batchedActions, __spreadArray([], __read(_this.machine.config.predictableActionArguments ? nextState.actions : nextState.actions.map(function(a) {
|
|
|
- return bindActionToState(a, nextState);
|
|
|
- })), false));
|
|
|
- batchChanged = batchChanged || !!nextState.changed;
|
|
|
- };
|
|
|
- try {
|
|
|
- for(var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()){
|
|
|
- var event_1 = events_1_1.value;
|
|
|
- _loop_1(event_1);
|
|
|
- }
|
|
|
- } catch (e_11_1) {
|
|
|
- e_11 = {
|
|
|
- error: e_11_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (events_1_1 && !events_1_1.done && (_a2 = events_1.return)) _a2.call(events_1);
|
|
|
- } finally{
|
|
|
- if (e_11) throw e_11.error;
|
|
|
- }
|
|
|
- }
|
|
|
- nextState.changed = batchChanged;
|
|
|
- nextState.actions = batchedActions;
|
|
|
- _this.update(nextState, toSCXMLEvent(events[events.length - 1]));
|
|
|
- });
|
|
|
- };
|
|
|
- Interpreter2.prototype.sender = function(event2) {
|
|
|
- return this.send.bind(this, event2);
|
|
|
- };
|
|
|
- Interpreter2.prototype._nextState = function(event2, exec) {
|
|
|
- var _this = this;
|
|
|
- if (exec === void 0) {
|
|
|
- exec = !!this.machine.config.predictableActionArguments && this._exec;
|
|
|
- }
|
|
|
- var _event = toSCXMLEvent(event2);
|
|
|
- if (_event.name.indexOf(errorPlatform) === 0 && !this.state.nextEvents.some(function(nextEvent) {
|
|
|
- return nextEvent.indexOf(errorPlatform) === 0;
|
|
|
- })) {
|
|
|
- throw _event.data.data;
|
|
|
- }
|
|
|
- var nextState = provide(this, function() {
|
|
|
- return _this.machine.transition(_this.state, _event, void 0, exec || void 0);
|
|
|
- });
|
|
|
- return nextState;
|
|
|
- };
|
|
|
- Interpreter2.prototype.nextState = function(event2) {
|
|
|
- return this._nextState(event2, false);
|
|
|
- };
|
|
|
- Interpreter2.prototype.forward = function(event2) {
|
|
|
- var e_12, _a2;
|
|
|
- try {
|
|
|
- for(var _b = __values(this.forwardTo), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var id = _c.value;
|
|
|
- var child = this.children.get(id);
|
|
|
- if (!child) {
|
|
|
- throw new Error("Unable to forward event '".concat(event2, "' from interpreter '").concat(this.id, "' to nonexistant child '").concat(id, "'."));
|
|
|
- }
|
|
|
- child.send(event2);
|
|
|
- }
|
|
|
- } catch (e_12_1) {
|
|
|
- e_12 = {
|
|
|
- error: e_12_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_12) throw e_12.error;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.defer = function(sendAction) {
|
|
|
- var _this = this;
|
|
|
- var timerId = this.clock.setTimeout(function() {
|
|
|
- if ("to" in sendAction && sendAction.to) {
|
|
|
- _this.sendTo(sendAction._event, sendAction.to, true);
|
|
|
- } else {
|
|
|
- _this.send(sendAction._event);
|
|
|
- }
|
|
|
- }, sendAction.delay);
|
|
|
- if (sendAction.id) {
|
|
|
- this.delayedEventsMap[sendAction.id] = timerId;
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.cancel = function(sendId) {
|
|
|
- this.clock.clearTimeout(this.delayedEventsMap[sendId]);
|
|
|
- delete this.delayedEventsMap[sendId];
|
|
|
- };
|
|
|
- Interpreter2.prototype.exec = function(action, state, actionFunctionMap) {
|
|
|
- if (actionFunctionMap === void 0) {
|
|
|
- actionFunctionMap = this.machine.options.actions;
|
|
|
- }
|
|
|
- this._exec(action, state.context, state._event, actionFunctionMap);
|
|
|
- };
|
|
|
- Interpreter2.prototype.removeChild = function(childId) {
|
|
|
- var _a2;
|
|
|
- this.children.delete(childId);
|
|
|
- this.forwardTo.delete(childId);
|
|
|
- (_a2 = this.state) === null || _a2 === void 0 ? true : delete _a2.children[childId];
|
|
|
- };
|
|
|
- Interpreter2.prototype.stopChild = function(childId) {
|
|
|
- var child = this.children.get(childId);
|
|
|
- if (!child) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.removeChild(childId);
|
|
|
- if (isFunction(child.stop)) {
|
|
|
- child.stop();
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawn = function(entity, name, options) {
|
|
|
- if (this.status !== InterpreterStatus.Running) {
|
|
|
- return createDeferredActor(entity, name);
|
|
|
- }
|
|
|
- if (isPromiseLike(entity)) {
|
|
|
- return this.spawnPromise(Promise.resolve(entity), name);
|
|
|
- } else if (isFunction(entity)) {
|
|
|
- return this.spawnCallback(entity, name);
|
|
|
- } else if (isSpawnedActor(entity)) {
|
|
|
- return this.spawnActor(entity, name);
|
|
|
- } else if (isObservable(entity)) {
|
|
|
- return this.spawnObservable(entity, name);
|
|
|
- } else if (isMachine(entity)) {
|
|
|
- return this.spawnMachine(entity, __assign(__assign({}, options), {
|
|
|
- id: name
|
|
|
- }));
|
|
|
- } else if (isBehavior(entity)) {
|
|
|
- return this.spawnBehavior(entity, name);
|
|
|
- } else {
|
|
|
- throw new Error('Unable to spawn entity "'.concat(name, '" of type "').concat(typeof entity, '".'));
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnMachine = function(machine, options) {
|
|
|
- var _this = this;
|
|
|
- if (options === void 0) {
|
|
|
- options = {};
|
|
|
- }
|
|
|
- var childService = new Interpreter2(machine, __assign(__assign({}, this.options), {
|
|
|
- parent: this,
|
|
|
- id: options.id || machine.id
|
|
|
- }));
|
|
|
- var resolvedOptions = __assign(__assign({}, DEFAULT_SPAWN_OPTIONS), options);
|
|
|
- if (resolvedOptions.sync) {
|
|
|
- childService.onTransition(function(state) {
|
|
|
- _this.send(update, {
|
|
|
- state,
|
|
|
- id: childService.id
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- var actor = childService;
|
|
|
- this.children.set(childService.id, actor);
|
|
|
- if (resolvedOptions.autoForward) {
|
|
|
- this.forwardTo.add(childService.id);
|
|
|
- }
|
|
|
- childService.onDone(function(doneEvent) {
|
|
|
- _this.removeChild(childService.id);
|
|
|
- _this.send(toSCXMLEvent(doneEvent, {
|
|
|
- origin: childService.id
|
|
|
- }));
|
|
|
- }).start();
|
|
|
- return actor;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnBehavior = function(behavior, id) {
|
|
|
- var actorRef = spawnBehavior(behavior, {
|
|
|
- id,
|
|
|
- parent: this
|
|
|
- });
|
|
|
- this.children.set(id, actorRef);
|
|
|
- return actorRef;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnPromise = function(promise, id) {
|
|
|
- var _a2;
|
|
|
- var _this = this;
|
|
|
- var canceled = false;
|
|
|
- var resolvedData;
|
|
|
- promise.then(function(response) {
|
|
|
- if (!canceled) {
|
|
|
- resolvedData = response;
|
|
|
- _this.removeChild(id);
|
|
|
- _this.send(toSCXMLEvent(doneInvoke(id, response), {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- }
|
|
|
- }, function(errorData) {
|
|
|
- if (!canceled) {
|
|
|
- _this.removeChild(id);
|
|
|
- var errorEvent = error2(id, errorData);
|
|
|
- try {
|
|
|
- _this.send(toSCXMLEvent(errorEvent, {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- } catch (error3) {
|
|
|
- reportUnhandledExceptionOnInvocation(errorData, error3, id);
|
|
|
- if (_this.devTools) {
|
|
|
- _this.devTools.send(errorEvent, _this.state);
|
|
|
- }
|
|
|
- if (_this.machine.strict) {
|
|
|
- _this.stop();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- var actor = (_a2 = {
|
|
|
- id,
|
|
|
- send: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- subscribe: function(next, handleError, complete) {
|
|
|
- var observer = toObserver(next, handleError, complete);
|
|
|
- var unsubscribed = false;
|
|
|
- promise.then(function(response) {
|
|
|
- if (unsubscribed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- observer.next(response);
|
|
|
- if (unsubscribed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- observer.complete();
|
|
|
- }, function(err) {
|
|
|
- if (unsubscribed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- observer.error(err);
|
|
|
- });
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- return unsubscribed = true;
|
|
|
- }
|
|
|
- };
|
|
|
- },
|
|
|
- stop: function() {
|
|
|
- canceled = true;
|
|
|
- },
|
|
|
- toJSON: function() {
|
|
|
- return {
|
|
|
- id
|
|
|
- };
|
|
|
- },
|
|
|
- getSnapshot: function() {
|
|
|
- return resolvedData;
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2);
|
|
|
- this.children.set(id, actor);
|
|
|
- return actor;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnCallback = function(callback, id) {
|
|
|
- var _a2;
|
|
|
- var _this = this;
|
|
|
- var canceled = false;
|
|
|
- var receivers = /* @__PURE__ */ new Set();
|
|
|
- var listeners = /* @__PURE__ */ new Set();
|
|
|
- var emitted;
|
|
|
- var receive = function(e) {
|
|
|
- emitted = e;
|
|
|
- listeners.forEach(function(listener) {
|
|
|
- return listener(e);
|
|
|
- });
|
|
|
- if (canceled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- _this.send(toSCXMLEvent(e, {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- };
|
|
|
- var callbackStop;
|
|
|
- try {
|
|
|
- callbackStop = callback(receive, function(newListener) {
|
|
|
- receivers.add(newListener);
|
|
|
- });
|
|
|
- } catch (err) {
|
|
|
- this.send(error2(id, err));
|
|
|
- }
|
|
|
- if (isPromiseLike(callbackStop)) {
|
|
|
- return this.spawnPromise(callbackStop, id);
|
|
|
- }
|
|
|
- var actor = (_a2 = {
|
|
|
- id,
|
|
|
- send: function(event2) {
|
|
|
- return receivers.forEach(function(receiver) {
|
|
|
- return receiver(event2);
|
|
|
- });
|
|
|
- },
|
|
|
- subscribe: function(next) {
|
|
|
- var observer = toObserver(next);
|
|
|
- listeners.add(observer.next);
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- listeners.delete(observer.next);
|
|
|
- }
|
|
|
- };
|
|
|
- },
|
|
|
- stop: function() {
|
|
|
- canceled = true;
|
|
|
- if (isFunction(callbackStop)) {
|
|
|
- callbackStop();
|
|
|
- }
|
|
|
- },
|
|
|
- toJSON: function() {
|
|
|
- return {
|
|
|
- id
|
|
|
- };
|
|
|
- },
|
|
|
- getSnapshot: function() {
|
|
|
- return emitted;
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2);
|
|
|
- this.children.set(id, actor);
|
|
|
- return actor;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnObservable = function(source, id) {
|
|
|
- var _a2;
|
|
|
- var _this = this;
|
|
|
- var emitted;
|
|
|
- var subscription = source.subscribe(function(value) {
|
|
|
- emitted = value;
|
|
|
- _this.send(toSCXMLEvent(value, {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- }, function(err) {
|
|
|
- _this.removeChild(id);
|
|
|
- _this.send(toSCXMLEvent(error2(id, err), {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- }, function() {
|
|
|
- _this.removeChild(id);
|
|
|
- _this.send(toSCXMLEvent(doneInvoke(id), {
|
|
|
- origin: id
|
|
|
- }));
|
|
|
- });
|
|
|
- var actor = (_a2 = {
|
|
|
- id,
|
|
|
- send: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- subscribe: function(next, handleError, complete) {
|
|
|
- return source.subscribe(next, handleError, complete);
|
|
|
- },
|
|
|
- stop: function() {
|
|
|
- return subscription.unsubscribe();
|
|
|
- },
|
|
|
- getSnapshot: function() {
|
|
|
- return emitted;
|
|
|
- },
|
|
|
- toJSON: function() {
|
|
|
- return {
|
|
|
- id
|
|
|
- };
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2);
|
|
|
- this.children.set(id, actor);
|
|
|
- return actor;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnActor = function(actor, name) {
|
|
|
- this.children.set(name, actor);
|
|
|
- return actor;
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnActivity = function(activity) {
|
|
|
- var implementation = this.machine.options && this.machine.options.activities ? this.machine.options.activities[activity.type] : void 0;
|
|
|
- if (!implementation) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "No implementation found for activity '".concat(activity.type, "'"));
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- var dispose = implementation(this.state.context, activity);
|
|
|
- this.spawnEffect(activity.id, dispose);
|
|
|
- };
|
|
|
- Interpreter2.prototype.spawnEffect = function(id, dispose) {
|
|
|
- var _a2;
|
|
|
- this.children.set(id, (_a2 = {
|
|
|
- id,
|
|
|
- send: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- subscribe: function() {
|
|
|
- return {
|
|
|
- unsubscribe: function() {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- };
|
|
|
- },
|
|
|
- stop: dispose || void 0,
|
|
|
- getSnapshot: function() {
|
|
|
- return void 0;
|
|
|
- },
|
|
|
- toJSON: function() {
|
|
|
- return {
|
|
|
- id
|
|
|
- };
|
|
|
- }
|
|
|
- }, _a2[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- }, _a2));
|
|
|
- };
|
|
|
- Interpreter2.prototype.attachDev = function() {
|
|
|
- var global2 = getGlobal();
|
|
|
- if (this.options.devTools && global2) {
|
|
|
- if (global2.__REDUX_DEVTOOLS_EXTENSION__) {
|
|
|
- var devToolsOptions = typeof this.options.devTools === "object" ? this.options.devTools : void 0;
|
|
|
- this.devTools = global2.__REDUX_DEVTOOLS_EXTENSION__.connect(__assign(__assign({
|
|
|
- name: this.id,
|
|
|
- autoPause: true,
|
|
|
- stateSanitizer: function(state) {
|
|
|
- return {
|
|
|
- value: state.value,
|
|
|
- context: state.context,
|
|
|
- actions: state.actions
|
|
|
- };
|
|
|
- }
|
|
|
- }, devToolsOptions), {
|
|
|
- features: __assign({
|
|
|
- jump: false,
|
|
|
- skip: false
|
|
|
- }, devToolsOptions ? devToolsOptions.features : void 0)
|
|
|
- }), this.machine);
|
|
|
- this.devTools.init(this.state);
|
|
|
- }
|
|
|
- registerService(this);
|
|
|
- }
|
|
|
- };
|
|
|
- Interpreter2.prototype.toJSON = function() {
|
|
|
- return {
|
|
|
- id: this.id
|
|
|
- };
|
|
|
- };
|
|
|
- Interpreter2.prototype[symbolObservable] = function() {
|
|
|
- return this;
|
|
|
- };
|
|
|
- Interpreter2.prototype.getSnapshot = function() {
|
|
|
- if (this.status === InterpreterStatus.NotStarted) {
|
|
|
- return this.initialState;
|
|
|
- }
|
|
|
- return this._state;
|
|
|
- };
|
|
|
- Interpreter2.defaultOptions = {
|
|
|
- execute: true,
|
|
|
- deferEvents: true,
|
|
|
- clock: {
|
|
|
- setTimeout: function(fn, ms) {
|
|
|
- return setTimeout(fn, ms);
|
|
|
- },
|
|
|
- clearTimeout: function(id) {
|
|
|
- return clearTimeout(id);
|
|
|
- }
|
|
|
- },
|
|
|
- logger: console.log.bind(console),
|
|
|
- devTools: false
|
|
|
- };
|
|
|
- Interpreter2.interpret = interpret;
|
|
|
- return Interpreter2;
|
|
|
-}();
|
|
|
-var resolveSpawnOptions = function(nameOrOptions) {
|
|
|
- if (isString(nameOrOptions)) {
|
|
|
- return __assign(__assign({}, DEFAULT_SPAWN_OPTIONS), {
|
|
|
- name: nameOrOptions
|
|
|
- });
|
|
|
- }
|
|
|
- return __assign(__assign(__assign({}, DEFAULT_SPAWN_OPTIONS), {
|
|
|
- name: uniqueId()
|
|
|
- }), nameOrOptions);
|
|
|
-};
|
|
|
-function spawn(entity, nameOrOptions) {
|
|
|
- var resolvedOptions = resolveSpawnOptions(nameOrOptions);
|
|
|
- return consume(function(service) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- var isLazyEntity = isMachine(entity) || isFunction(entity);
|
|
|
- warn(!!service || isLazyEntity, 'Attempted to spawn an Actor (ID: "'.concat(isMachine(entity) ? entity.id : "undefined", '") outside of a service. This will have no effect.'));
|
|
|
- }
|
|
|
- if (service) {
|
|
|
- return service.spawn(entity, resolvedOptions.name, resolvedOptions);
|
|
|
- } else {
|
|
|
- return createDeferredActor(entity, resolvedOptions.name);
|
|
|
- }
|
|
|
- });
|
|
|
-}
|
|
|
-function interpret(machine, options) {
|
|
|
- var interpreter = new Interpreter(machine, options);
|
|
|
- return interpreter;
|
|
|
-}
|
|
|
-// node_modules/xstate/es/invokeUtils.js
|
|
|
-function toInvokeSource2(src) {
|
|
|
- if (typeof src === "string") {
|
|
|
- var simpleSrc = {
|
|
|
- type: src
|
|
|
- };
|
|
|
- simpleSrc.toString = function() {
|
|
|
- return src;
|
|
|
- };
|
|
|
- return simpleSrc;
|
|
|
- }
|
|
|
- return src;
|
|
|
-}
|
|
|
-function toInvokeDefinition(invokeConfig) {
|
|
|
- return __assign(__assign({
|
|
|
- type: invoke
|
|
|
- }, invokeConfig), {
|
|
|
- toJSON: function() {
|
|
|
- invokeConfig.onDone;
|
|
|
- invokeConfig.onError;
|
|
|
- var invokeDef = __rest(invokeConfig, [
|
|
|
- "onDone",
|
|
|
- "onError"
|
|
|
- ]);
|
|
|
- return __assign(__assign({}, invokeDef), {
|
|
|
- type: invoke,
|
|
|
- src: toInvokeSource2(invokeConfig.src)
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
-}
|
|
|
-// node_modules/xstate/es/StateNode.js
|
|
|
-var NULL_EVENT = "";
|
|
|
-var STATE_IDENTIFIER = "#";
|
|
|
-var WILDCARD = "*";
|
|
|
-var EMPTY_OBJECT = {};
|
|
|
-var isStateId = function(str) {
|
|
|
- return str[0] === STATE_IDENTIFIER;
|
|
|
-};
|
|
|
-var createDefaultOptions = function() {
|
|
|
- return {
|
|
|
- actions: {},
|
|
|
- guards: {},
|
|
|
- services: {},
|
|
|
- activities: {},
|
|
|
- delays: {}
|
|
|
- };
|
|
|
-};
|
|
|
-var validateArrayifiedTransitions = function(stateNode, event2, transitions) {
|
|
|
- var hasNonLastUnguardedTarget = transitions.slice(0, -1).some(function(transition) {
|
|
|
- return !("cond" in transition) && !("in" in transition) && (isString(transition.target) || isMachine(transition.target));
|
|
|
- });
|
|
|
- var eventText = event2 === NULL_EVENT ? "the transient event" : "event '".concat(event2, "'");
|
|
|
- warn(!hasNonLastUnguardedTarget, "One or more transitions for ".concat(eventText, " on state '").concat(stateNode.id, "' are unreachable. ") + "Make sure that the default transition is the last one defined.");
|
|
|
-};
|
|
|
-var StateNode = function() {
|
|
|
- function StateNode2(config, options, _context, _stateInfo) {
|
|
|
- if (_context === void 0) {
|
|
|
- _context = "context" in config ? config.context : void 0;
|
|
|
- }
|
|
|
- var _this = this;
|
|
|
- var _a2;
|
|
|
- this.config = config;
|
|
|
- this._context = _context;
|
|
|
- this.order = -1;
|
|
|
- this.__xstatenode = true;
|
|
|
- this.__cache = {
|
|
|
- events: void 0,
|
|
|
- relativeValue: /* @__PURE__ */ new Map(),
|
|
|
- initialStateValue: void 0,
|
|
|
- initialState: void 0,
|
|
|
- on: void 0,
|
|
|
- transitions: void 0,
|
|
|
- candidates: {},
|
|
|
- delayedTransitions: void 0
|
|
|
- };
|
|
|
- this.idMap = {};
|
|
|
- this.tags = [];
|
|
|
- this.options = Object.assign(createDefaultOptions(), options);
|
|
|
- this.parent = _stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.parent;
|
|
|
- this.key = this.config.key || (_stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.key) || this.config.id || "(machine)";
|
|
|
- this.machine = this.parent ? this.parent.machine : this;
|
|
|
- this.path = this.parent ? this.parent.path.concat(this.key) : [];
|
|
|
- this.delimiter = this.config.delimiter || (this.parent ? this.parent.delimiter : STATE_DELIMITER);
|
|
|
- this.id = this.config.id || __spreadArray([
|
|
|
- this.machine.key
|
|
|
- ], __read(this.path), false).join(this.delimiter);
|
|
|
- this.version = this.parent ? this.parent.version : this.config.version;
|
|
|
- this.type = this.config.type || (this.config.parallel ? "parallel" : this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic");
|
|
|
- this.schema = this.parent ? this.machine.schema : (_a2 = this.config.schema) !== null && _a2 !== void 0 ? _a2 : {};
|
|
|
- this.description = this.config.description;
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(!("parallel" in this.config), 'The "parallel" property is deprecated and will be removed in version 4.1. '.concat(this.config.parallel ? "Replace with `type: 'parallel'`" : "Use `type: '".concat(this.type, "'`"), " in the config for state node '").concat(this.id, "' instead."));
|
|
|
- }
|
|
|
- this.initial = this.config.initial;
|
|
|
- this.states = this.config.states ? mapValues(this.config.states, function(stateConfig, key) {
|
|
|
- var _a3;
|
|
|
- var stateNode = new StateNode2(stateConfig, {}, void 0, {
|
|
|
- parent: _this,
|
|
|
- key
|
|
|
- });
|
|
|
- Object.assign(_this.idMap, __assign((_a3 = {}, _a3[stateNode.id] = stateNode, _a3), stateNode.idMap));
|
|
|
- return stateNode;
|
|
|
- }) : EMPTY_OBJECT;
|
|
|
- var order = 0;
|
|
|
- function dfs(stateNode) {
|
|
|
- var e_1, _a3;
|
|
|
- stateNode.order = order++;
|
|
|
- try {
|
|
|
- for(var _b = __values(getAllChildren(stateNode)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var child = _c.value;
|
|
|
- dfs(child);
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a3 = _b.return)) _a3.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- dfs(this);
|
|
|
- this.history = this.config.history === true ? "shallow" : this.config.history || false;
|
|
|
- this._transient = !!this.config.always || (!this.config.on ? false : Array.isArray(this.config.on) ? this.config.on.some(function(_a3) {
|
|
|
- var event2 = _a3.event;
|
|
|
- return event2 === NULL_EVENT;
|
|
|
- }) : NULL_EVENT in this.config.on);
|
|
|
- this.strict = !!this.config.strict;
|
|
|
- this.onEntry = toArray(this.config.entry || this.config.onEntry).map(function(action) {
|
|
|
- return toActionObject(action);
|
|
|
- });
|
|
|
- this.onExit = toArray(this.config.exit || this.config.onExit).map(function(action) {
|
|
|
- return toActionObject(action);
|
|
|
- });
|
|
|
- this.meta = this.config.meta;
|
|
|
- this.doneData = this.type === "final" ? this.config.data : void 0;
|
|
|
- this.invoke = toArray(this.config.invoke).map(function(invokeConfig, i) {
|
|
|
- var _a3, _b;
|
|
|
- if (isMachine(invokeConfig)) {
|
|
|
- var invokeId = createInvokeId(_this.id, i);
|
|
|
- _this.machine.options.services = __assign((_a3 = {}, _a3[invokeId] = invokeConfig, _a3), _this.machine.options.services);
|
|
|
- return toInvokeDefinition({
|
|
|
- src: invokeId,
|
|
|
- id: invokeId
|
|
|
- });
|
|
|
- } else if (isString(invokeConfig.src)) {
|
|
|
- var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
|
|
|
- return toInvokeDefinition(__assign(__assign({}, invokeConfig), {
|
|
|
- id: invokeId,
|
|
|
- src: invokeConfig.src
|
|
|
- }));
|
|
|
- } else if (isMachine(invokeConfig.src) || isFunction(invokeConfig.src)) {
|
|
|
- var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
|
|
|
- _this.machine.options.services = __assign((_b = {}, _b[invokeId] = invokeConfig.src, _b), _this.machine.options.services);
|
|
|
- return toInvokeDefinition(__assign(__assign({
|
|
|
- id: invokeId
|
|
|
- }, invokeConfig), {
|
|
|
- src: invokeId
|
|
|
- }));
|
|
|
- } else {
|
|
|
- var invokeSource = invokeConfig.src;
|
|
|
- return toInvokeDefinition(__assign(__assign({
|
|
|
- id: createInvokeId(_this.id, i)
|
|
|
- }, invokeConfig), {
|
|
|
- src: invokeSource
|
|
|
- }));
|
|
|
- }
|
|
|
- });
|
|
|
- this.activities = toArray(this.config.activities).concat(this.invoke).map(function(activity) {
|
|
|
- return toActivityDefinition(activity);
|
|
|
- });
|
|
|
- this.transition = this.transition.bind(this);
|
|
|
- this.tags = toArray(this.config.tags);
|
|
|
- }
|
|
|
- StateNode2.prototype._init = function() {
|
|
|
- if (this.__cache.transitions) {
|
|
|
- return;
|
|
|
- }
|
|
|
- getAllStateNodes(this).forEach(function(stateNode) {
|
|
|
- return stateNode.on;
|
|
|
- });
|
|
|
- };
|
|
|
- StateNode2.prototype.withConfig = function(options, context) {
|
|
|
- var _a2 = this.options, actions = _a2.actions, activities = _a2.activities, guards = _a2.guards, services = _a2.services, delays = _a2.delays;
|
|
|
- return new StateNode2(this.config, {
|
|
|
- actions: __assign(__assign({}, actions), options.actions),
|
|
|
- activities: __assign(__assign({}, activities), options.activities),
|
|
|
- guards: __assign(__assign({}, guards), options.guards),
|
|
|
- services: __assign(__assign({}, services), options.services),
|
|
|
- delays: __assign(__assign({}, delays), options.delays)
|
|
|
- }, context !== null && context !== void 0 ? context : this.context);
|
|
|
- };
|
|
|
- StateNode2.prototype.withContext = function(context) {
|
|
|
- return new StateNode2(this.config, this.options, context);
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "context", {
|
|
|
- get: function() {
|
|
|
- return isFunction(this._context) ? this._context() : this._context;
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "definition", {
|
|
|
- get: function() {
|
|
|
- return {
|
|
|
- id: this.id,
|
|
|
- key: this.key,
|
|
|
- version: this.version,
|
|
|
- context: this.context,
|
|
|
- type: this.type,
|
|
|
- initial: this.initial,
|
|
|
- history: this.history,
|
|
|
- states: mapValues(this.states, function(state) {
|
|
|
- return state.definition;
|
|
|
- }),
|
|
|
- on: this.on,
|
|
|
- transitions: this.transitions,
|
|
|
- entry: this.onEntry,
|
|
|
- exit: this.onExit,
|
|
|
- activities: this.activities || [],
|
|
|
- meta: this.meta,
|
|
|
- order: this.order || -1,
|
|
|
- data: this.doneData,
|
|
|
- invoke: this.invoke,
|
|
|
- description: this.description,
|
|
|
- tags: this.tags
|
|
|
- };
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.toJSON = function() {
|
|
|
- return this.definition;
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "on", {
|
|
|
- get: function() {
|
|
|
- if (this.__cache.on) {
|
|
|
- return this.__cache.on;
|
|
|
- }
|
|
|
- var transitions = this.transitions;
|
|
|
- return this.__cache.on = transitions.reduce(function(map, transition) {
|
|
|
- map[transition.eventType] = map[transition.eventType] || [];
|
|
|
- map[transition.eventType].push(transition);
|
|
|
- return map;
|
|
|
- }, {});
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "after", {
|
|
|
- get: function() {
|
|
|
- return this.__cache.delayedTransitions || (this.__cache.delayedTransitions = this.getDelayedTransitions(), this.__cache.delayedTransitions);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "transitions", {
|
|
|
- get: function() {
|
|
|
- return this.__cache.transitions || (this.__cache.transitions = this.formatTransitions(), this.__cache.transitions);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.getCandidates = function(eventName) {
|
|
|
- if (this.__cache.candidates[eventName]) {
|
|
|
- return this.__cache.candidates[eventName];
|
|
|
- }
|
|
|
- var transient = eventName === NULL_EVENT;
|
|
|
- var candidates = this.transitions.filter(function(transition) {
|
|
|
- var sameEventType = transition.eventType === eventName;
|
|
|
- return transient ? sameEventType : sameEventType || transition.eventType === WILDCARD;
|
|
|
- });
|
|
|
- this.__cache.candidates[eventName] = candidates;
|
|
|
- return candidates;
|
|
|
- };
|
|
|
- StateNode2.prototype.getDelayedTransitions = function() {
|
|
|
- var _this = this;
|
|
|
- var afterConfig = this.config.after;
|
|
|
- if (!afterConfig) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- var mutateEntryExit = function(delay, i) {
|
|
|
- var delayRef = isFunction(delay) ? "".concat(_this.id, ":delay[").concat(i, "]") : delay;
|
|
|
- var eventType = after2(delayRef, _this.id);
|
|
|
- _this.onEntry.push(send2(eventType, {
|
|
|
- delay
|
|
|
- }));
|
|
|
- _this.onExit.push(cancel2(eventType));
|
|
|
- return eventType;
|
|
|
- };
|
|
|
- var delayedTransitions = isArray(afterConfig) ? afterConfig.map(function(transition, i) {
|
|
|
- var eventType = mutateEntryExit(transition.delay, i);
|
|
|
- return __assign(__assign({}, transition), {
|
|
|
- event: eventType
|
|
|
- });
|
|
|
- }) : flatten(Object.keys(afterConfig).map(function(delay, i) {
|
|
|
- var configTransition = afterConfig[delay];
|
|
|
- var resolvedTransition = isString(configTransition) ? {
|
|
|
- target: configTransition
|
|
|
- } : configTransition;
|
|
|
- var resolvedDelay = !isNaN(+delay) ? +delay : delay;
|
|
|
- var eventType = mutateEntryExit(resolvedDelay, i);
|
|
|
- return toArray(resolvedTransition).map(function(transition) {
|
|
|
- return __assign(__assign({}, transition), {
|
|
|
- event: eventType,
|
|
|
- delay: resolvedDelay
|
|
|
- });
|
|
|
- });
|
|
|
- }));
|
|
|
- return delayedTransitions.map(function(delayedTransition) {
|
|
|
- var delay = delayedTransition.delay;
|
|
|
- return __assign(__assign({}, _this.formatTransition(delayedTransition)), {
|
|
|
- delay
|
|
|
- });
|
|
|
- });
|
|
|
- };
|
|
|
- StateNode2.prototype.getStateNodes = function(state) {
|
|
|
- var _a2;
|
|
|
- var _this = this;
|
|
|
- if (!state) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- var stateValue = state instanceof State ? state.value : toStateValue(state, this.delimiter);
|
|
|
- if (isString(stateValue)) {
|
|
|
- var initialStateValue = this.getStateNode(stateValue).initial;
|
|
|
- return initialStateValue !== void 0 ? this.getStateNodes((_a2 = {}, _a2[stateValue] = initialStateValue, _a2)) : [
|
|
|
- this,
|
|
|
- this.states[stateValue]
|
|
|
- ];
|
|
|
- }
|
|
|
- var subStateKeys = Object.keys(stateValue);
|
|
|
- var subStateNodes = [
|
|
|
- this
|
|
|
- ];
|
|
|
- subStateNodes.push.apply(subStateNodes, __spreadArray([], __read(flatten(subStateKeys.map(function(subStateKey) {
|
|
|
- return _this.getStateNode(subStateKey).getStateNodes(stateValue[subStateKey]);
|
|
|
- }))), false));
|
|
|
- return subStateNodes;
|
|
|
- };
|
|
|
- StateNode2.prototype.handles = function(event2) {
|
|
|
- var eventType = getEventType(event2);
|
|
|
- return this.events.includes(eventType);
|
|
|
- };
|
|
|
- StateNode2.prototype.resolveState = function(state) {
|
|
|
- var stateFromConfig = state instanceof State ? state : State.create(state);
|
|
|
- var configuration = Array.from(getConfiguration([], this.getStateNodes(stateFromConfig.value)));
|
|
|
- return new State(__assign(__assign({}, stateFromConfig), {
|
|
|
- value: this.resolve(stateFromConfig.value),
|
|
|
- configuration,
|
|
|
- done: isInFinalState(configuration, this),
|
|
|
- tags: getTagsFromConfiguration(configuration),
|
|
|
- machine: this.machine
|
|
|
- }));
|
|
|
- };
|
|
|
- StateNode2.prototype.transitionLeafNode = function(stateValue, state, _event) {
|
|
|
- var stateNode = this.getStateNode(stateValue);
|
|
|
- var next = stateNode.next(state, _event);
|
|
|
- if (!next || !next.transitions.length) {
|
|
|
- return this.next(state, _event);
|
|
|
- }
|
|
|
- return next;
|
|
|
- };
|
|
|
- StateNode2.prototype.transitionCompoundNode = function(stateValue, state, _event) {
|
|
|
- var subStateKeys = Object.keys(stateValue);
|
|
|
- var stateNode = this.getStateNode(subStateKeys[0]);
|
|
|
- var next = stateNode._transition(stateValue[subStateKeys[0]], state, _event);
|
|
|
- if (!next || !next.transitions.length) {
|
|
|
- return this.next(state, _event);
|
|
|
- }
|
|
|
- return next;
|
|
|
- };
|
|
|
- StateNode2.prototype.transitionParallelNode = function(stateValue, state, _event) {
|
|
|
- var e_2, _a2;
|
|
|
- var transitionMap = {};
|
|
|
- try {
|
|
|
- for(var _b = __values(Object.keys(stateValue)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var subStateKey = _c.value;
|
|
|
- var subStateValue = stateValue[subStateKey];
|
|
|
- if (!subStateValue) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- var subStateNode = this.getStateNode(subStateKey);
|
|
|
- var next = subStateNode._transition(subStateValue, state, _event);
|
|
|
- if (next) {
|
|
|
- transitionMap[subStateKey] = next;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_2_1) {
|
|
|
- e_2 = {
|
|
|
- error: e_2_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_2) throw e_2.error;
|
|
|
- }
|
|
|
- }
|
|
|
- var stateTransitions = Object.keys(transitionMap).map(function(key) {
|
|
|
- return transitionMap[key];
|
|
|
- });
|
|
|
- var enabledTransitions = flatten(stateTransitions.map(function(st) {
|
|
|
- return st.transitions;
|
|
|
- }));
|
|
|
- var willTransition = stateTransitions.some(function(st) {
|
|
|
- return st.transitions.length > 0;
|
|
|
- });
|
|
|
- if (!willTransition) {
|
|
|
- return this.next(state, _event);
|
|
|
- }
|
|
|
- var configuration = flatten(Object.keys(transitionMap).map(function(key) {
|
|
|
- return transitionMap[key].configuration;
|
|
|
- }));
|
|
|
- return {
|
|
|
- transitions: enabledTransitions,
|
|
|
- exitSet: flatten(stateTransitions.map(function(t2) {
|
|
|
- return t2.exitSet;
|
|
|
- })),
|
|
|
- configuration,
|
|
|
- source: state,
|
|
|
- actions: flatten(Object.keys(transitionMap).map(function(key) {
|
|
|
- return transitionMap[key].actions;
|
|
|
- }))
|
|
|
- };
|
|
|
- };
|
|
|
- StateNode2.prototype._transition = function(stateValue, state, _event) {
|
|
|
- if (isString(stateValue)) {
|
|
|
- return this.transitionLeafNode(stateValue, state, _event);
|
|
|
- }
|
|
|
- if (Object.keys(stateValue).length === 1) {
|
|
|
- return this.transitionCompoundNode(stateValue, state, _event);
|
|
|
- }
|
|
|
- return this.transitionParallelNode(stateValue, state, _event);
|
|
|
- };
|
|
|
- StateNode2.prototype.getTransitionData = function(state, event2) {
|
|
|
- return this._transition(state.value, state, toSCXMLEvent(event2));
|
|
|
- };
|
|
|
- StateNode2.prototype.next = function(state, _event) {
|
|
|
- var e_3, _a2;
|
|
|
- var _this = this;
|
|
|
- var eventName = _event.name;
|
|
|
- var actions = [];
|
|
|
- var nextStateNodes = [];
|
|
|
- var selectedTransition;
|
|
|
- try {
|
|
|
- for(var _b = __values(this.getCandidates(eventName)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var candidate = _c.value;
|
|
|
- var cond = candidate.cond, stateIn = candidate.in;
|
|
|
- var resolvedContext = state.context;
|
|
|
- var isInState = stateIn ? isString(stateIn) && isStateId(stateIn) ? state.matches(toStateValue(this.getStateNodeById(stateIn).path, this.delimiter)) : matchesState(toStateValue(stateIn, this.delimiter), path(this.path.slice(0, -2))(state.value)) : true;
|
|
|
- var guardPassed = false;
|
|
|
- try {
|
|
|
- guardPassed = !cond || evaluateGuard(this.machine, cond, resolvedContext, _event, state);
|
|
|
- } catch (err) {
|
|
|
- throw new Error("Unable to evaluate guard '".concat(cond.name || cond.type, "' in transition for event '").concat(eventName, "' in state node '").concat(this.id, "':\n").concat(err.message));
|
|
|
- }
|
|
|
- if (guardPassed && isInState) {
|
|
|
- if (candidate.target !== void 0) {
|
|
|
- nextStateNodes = candidate.target;
|
|
|
- }
|
|
|
- actions.push.apply(actions, __spreadArray([], __read(candidate.actions), false));
|
|
|
- selectedTransition = candidate;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_3_1) {
|
|
|
- e_3 = {
|
|
|
- error: e_3_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_3) throw e_3.error;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!selectedTransition) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- if (!nextStateNodes.length) {
|
|
|
- return {
|
|
|
- transitions: [
|
|
|
- selectedTransition
|
|
|
- ],
|
|
|
- exitSet: [],
|
|
|
- configuration: state.value ? [
|
|
|
- this
|
|
|
- ] : [],
|
|
|
- source: state,
|
|
|
- actions
|
|
|
- };
|
|
|
- }
|
|
|
- var allNextStateNodes = flatten(nextStateNodes.map(function(stateNode) {
|
|
|
- return _this.getRelativeStateNodes(stateNode, state.historyValue);
|
|
|
- }));
|
|
|
- var isInternal = !!selectedTransition.internal;
|
|
|
- return {
|
|
|
- transitions: [
|
|
|
- selectedTransition
|
|
|
- ],
|
|
|
- exitSet: isInternal ? [] : flatten(nextStateNodes.map(function(targetNode) {
|
|
|
- return _this.getPotentiallyReenteringNodes(targetNode);
|
|
|
- })),
|
|
|
- configuration: allNextStateNodes,
|
|
|
- source: state,
|
|
|
- actions
|
|
|
- };
|
|
|
- };
|
|
|
- StateNode2.prototype.getPotentiallyReenteringNodes = function(targetNode) {
|
|
|
- if (this.order < targetNode.order) {
|
|
|
- return [
|
|
|
- this
|
|
|
- ];
|
|
|
- }
|
|
|
- var nodes = [];
|
|
|
- var marker = this;
|
|
|
- var possibleAncestor = targetNode;
|
|
|
- while(marker && marker !== possibleAncestor){
|
|
|
- nodes.push(marker);
|
|
|
- marker = marker.parent;
|
|
|
- }
|
|
|
- if (marker !== possibleAncestor) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- nodes.push(possibleAncestor);
|
|
|
- return nodes;
|
|
|
- };
|
|
|
- StateNode2.prototype.getActions = function(resolvedConfig, isDone, transition, currentContext, _event, prevState, predictableExec) {
|
|
|
- var e_4, _a2, e_5, _b;
|
|
|
- var _this = this;
|
|
|
- var prevConfig = prevState ? getConfiguration([], this.getStateNodes(prevState.value)) : [];
|
|
|
- var entrySet = /* @__PURE__ */ new Set();
|
|
|
- try {
|
|
|
- for(var _c = __values(Array.from(resolvedConfig).sort(function(a, b) {
|
|
|
- return a.order - b.order;
|
|
|
- })), _d = _c.next(); !_d.done; _d = _c.next()){
|
|
|
- var sn = _d.value;
|
|
|
- if (!has(prevConfig, sn) || has(transition.exitSet, sn) || sn.parent && entrySet.has(sn.parent)) {
|
|
|
- entrySet.add(sn);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_4_1) {
|
|
|
- e_4 = {
|
|
|
- error: e_4_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_d && !_d.done && (_a2 = _c.return)) _a2.call(_c);
|
|
|
- } finally{
|
|
|
- if (e_4) throw e_4.error;
|
|
|
- }
|
|
|
- }
|
|
|
- try {
|
|
|
- for(var prevConfig_1 = __values(prevConfig), prevConfig_1_1 = prevConfig_1.next(); !prevConfig_1_1.done; prevConfig_1_1 = prevConfig_1.next()){
|
|
|
- var sn = prevConfig_1_1.value;
|
|
|
- if (!has(resolvedConfig, sn) || has(transition.exitSet, sn.parent)) {
|
|
|
- transition.exitSet.push(sn);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_5_1) {
|
|
|
- e_5 = {
|
|
|
- error: e_5_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (prevConfig_1_1 && !prevConfig_1_1.done && (_b = prevConfig_1.return)) _b.call(prevConfig_1);
|
|
|
- } finally{
|
|
|
- if (e_5) throw e_5.error;
|
|
|
- }
|
|
|
- }
|
|
|
- transition.exitSet.sort(function(a, b) {
|
|
|
- return b.order - a.order;
|
|
|
- });
|
|
|
- var entryStates = Array.from(entrySet).sort(function(a, b) {
|
|
|
- return a.order - b.order;
|
|
|
- });
|
|
|
- var exitStates = new Set(transition.exitSet);
|
|
|
- var doneEvents = flatten(entryStates.map(function(sn2) {
|
|
|
- var events = [];
|
|
|
- if (sn2.type !== "final") {
|
|
|
- return events;
|
|
|
- }
|
|
|
- var parent = sn2.parent;
|
|
|
- if (!parent.parent) {
|
|
|
- return events;
|
|
|
- }
|
|
|
- events.push(done(sn2.id, sn2.doneData), done(parent.id, sn2.doneData ? mapContext(sn2.doneData, currentContext, _event) : void 0));
|
|
|
- var grandparent = parent.parent;
|
|
|
- if (grandparent.type === "parallel") {
|
|
|
- if (getChildren(grandparent).every(function(parentNode) {
|
|
|
- return isInFinalState(transition.configuration, parentNode);
|
|
|
- })) {
|
|
|
- events.push(done(grandparent.id));
|
|
|
- }
|
|
|
- }
|
|
|
- return events;
|
|
|
- }));
|
|
|
- var entryActions = entryStates.map(function(stateNode) {
|
|
|
- var entryActions2 = stateNode.onEntry;
|
|
|
- var invokeActions = stateNode.activities.map(function(activity) {
|
|
|
- return start2(activity);
|
|
|
- });
|
|
|
- return {
|
|
|
- type: "entry",
|
|
|
- actions: toActionObjects(predictableExec ? __spreadArray(__spreadArray([], __read(entryActions2), false), __read(invokeActions), false) : __spreadArray(__spreadArray([], __read(invokeActions), false), __read(entryActions2), false), _this.machine.options.actions)
|
|
|
- };
|
|
|
- }).concat({
|
|
|
- type: "state_done",
|
|
|
- actions: doneEvents.map(function(event2) {
|
|
|
- return raise2(event2);
|
|
|
- })
|
|
|
- });
|
|
|
- var exitActions = Array.from(exitStates).map(function(stateNode) {
|
|
|
- return {
|
|
|
- type: "exit",
|
|
|
- actions: toActionObjects(__spreadArray(__spreadArray([], __read(stateNode.onExit), false), __read(stateNode.activities.map(function(activity) {
|
|
|
- return stop2(activity);
|
|
|
- })), false), _this.machine.options.actions)
|
|
|
- };
|
|
|
- });
|
|
|
- var actions = exitActions.concat({
|
|
|
- type: "transition",
|
|
|
- actions: toActionObjects(transition.actions, this.machine.options.actions)
|
|
|
- }).concat(entryActions);
|
|
|
- if (isDone) {
|
|
|
- var stopActions = toActionObjects(flatten(__spreadArray([], __read(resolvedConfig), false).sort(function(a, b) {
|
|
|
- return b.order - a.order;
|
|
|
- }).map(function(stateNode) {
|
|
|
- return stateNode.onExit;
|
|
|
- })), this.machine.options.actions).filter(function(action) {
|
|
|
- return !isRaisableAction(action);
|
|
|
- });
|
|
|
- return actions.concat({
|
|
|
- type: "stop",
|
|
|
- actions: stopActions
|
|
|
- });
|
|
|
- }
|
|
|
- return actions;
|
|
|
- };
|
|
|
- StateNode2.prototype.transition = function(state, event2, context, exec) {
|
|
|
- if (state === void 0) {
|
|
|
- state = this.initialState;
|
|
|
- }
|
|
|
- var _event = toSCXMLEvent(event2);
|
|
|
- var currentState;
|
|
|
- if (state instanceof State) {
|
|
|
- currentState = context === void 0 ? state : this.resolveState(State.from(state, context));
|
|
|
- } else {
|
|
|
- var resolvedStateValue = isString(state) ? this.resolve(pathToStateValue(this.getResolvedPath(state))) : this.resolve(state);
|
|
|
- var resolvedContext = context !== null && context !== void 0 ? context : this.machine.context;
|
|
|
- currentState = this.resolveState(State.from(resolvedStateValue, resolvedContext));
|
|
|
- }
|
|
|
- if (!IS_PRODUCTION && _event.name === WILDCARD) {
|
|
|
- throw new Error("An event cannot have the wildcard type ('".concat(WILDCARD, "')"));
|
|
|
- }
|
|
|
- if (this.strict) {
|
|
|
- if (!this.events.includes(_event.name) && !isBuiltInEvent(_event.name)) {
|
|
|
- throw new Error("Machine '".concat(this.id, "' does not accept event '").concat(_event.name, "'"));
|
|
|
- }
|
|
|
- }
|
|
|
- var stateTransition = this._transition(currentState.value, currentState, _event) || {
|
|
|
- transitions: [],
|
|
|
- configuration: [],
|
|
|
- exitSet: [],
|
|
|
- source: currentState,
|
|
|
- actions: []
|
|
|
- };
|
|
|
- var prevConfig = getConfiguration([], this.getStateNodes(currentState.value));
|
|
|
- var resolvedConfig = stateTransition.configuration.length ? getConfiguration(prevConfig, stateTransition.configuration) : prevConfig;
|
|
|
- stateTransition.configuration = __spreadArray([], __read(resolvedConfig), false);
|
|
|
- return this.resolveTransition(stateTransition, currentState, currentState.context, exec, _event);
|
|
|
- };
|
|
|
- StateNode2.prototype.resolveRaisedTransition = function(state, _event, originalEvent, predictableExec) {
|
|
|
- var _a2;
|
|
|
- var currentActions = state.actions;
|
|
|
- state = this.transition(state, _event, void 0, predictableExec);
|
|
|
- state._event = originalEvent;
|
|
|
- state.event = originalEvent.data;
|
|
|
- (_a2 = state.actions).unshift.apply(_a2, __spreadArray([], __read(currentActions), false));
|
|
|
- return state;
|
|
|
- };
|
|
|
- StateNode2.prototype.resolveTransition = function(stateTransition, currentState, context, predictableExec, _event) {
|
|
|
- var e_6, _a2, e_7, _b;
|
|
|
- var _this = this;
|
|
|
- if (_event === void 0) {
|
|
|
- _event = initEvent;
|
|
|
- }
|
|
|
- var configuration = stateTransition.configuration;
|
|
|
- var willTransition = !currentState || stateTransition.transitions.length > 0;
|
|
|
- var resolvedConfiguration = willTransition ? stateTransition.configuration : currentState ? currentState.configuration : [];
|
|
|
- var isDone = isInFinalState(resolvedConfiguration, this);
|
|
|
- var resolvedStateValue = willTransition ? getValue(this.machine, configuration) : void 0;
|
|
|
- var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : void 0 : void 0;
|
|
|
- var actionBlocks = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState, predictableExec);
|
|
|
- var activities = currentState ? __assign({}, currentState.activities) : {};
|
|
|
- try {
|
|
|
- for(var actionBlocks_1 = __values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()){
|
|
|
- var block = actionBlocks_1_1.value;
|
|
|
- try {
|
|
|
- for(var _c = (e_7 = void 0, __values(block.actions)), _d = _c.next(); !_d.done; _d = _c.next()){
|
|
|
- var action = _d.value;
|
|
|
- if (action.type === start) {
|
|
|
- activities[action.activity.id || action.activity.type] = action;
|
|
|
- } else if (action.type === stop) {
|
|
|
- activities[action.activity.id || action.activity.type] = false;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_7_1) {
|
|
|
- e_7 = {
|
|
|
- error: e_7_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
|
|
|
- } finally{
|
|
|
- if (e_7) throw e_7.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_6_1) {
|
|
|
- e_6 = {
|
|
|
- error: e_6_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a2 = actionBlocks_1.return)) _a2.call(actionBlocks_1);
|
|
|
- } finally{
|
|
|
- if (e_6) throw e_6.error;
|
|
|
- }
|
|
|
- }
|
|
|
- var _e = __read(resolveActions(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2), resolvedActions = _e[0], updatedContext = _e[1];
|
|
|
- var _f = __read(partition(resolvedActions, isRaisableAction), 2), raisedEvents = _f[0], nonRaisedActions = _f[1];
|
|
|
- var invokeActions = resolvedActions.filter(function(action2) {
|
|
|
- var _a3;
|
|
|
- return action2.type === start && ((_a3 = action2.activity) === null || _a3 === void 0 ? void 0 : _a3.type) === invoke;
|
|
|
- });
|
|
|
- var children2 = invokeActions.reduce(function(acc, action2) {
|
|
|
- acc[action2.activity.id] = createInvocableActor(action2.activity, _this.machine, updatedContext, _event);
|
|
|
- return acc;
|
|
|
- }, currentState ? __assign({}, currentState.children) : {});
|
|
|
- var nextState = new State({
|
|
|
- value: resolvedStateValue || currentState.value,
|
|
|
- context: updatedContext,
|
|
|
- _event,
|
|
|
- _sessionid: currentState ? currentState._sessionid : null,
|
|
|
- historyValue: resolvedStateValue ? historyValue ? updateHistoryValue(historyValue, resolvedStateValue) : void 0 : currentState ? currentState.historyValue : void 0,
|
|
|
- history: !resolvedStateValue || stateTransition.source ? currentState : void 0,
|
|
|
- actions: resolvedStateValue ? nonRaisedActions : [],
|
|
|
- activities: resolvedStateValue ? activities : currentState ? currentState.activities : {},
|
|
|
- events: [],
|
|
|
- configuration: resolvedConfiguration,
|
|
|
- transitions: stateTransition.transitions,
|
|
|
- children: children2,
|
|
|
- done: isDone,
|
|
|
- tags: getTagsFromConfiguration(resolvedConfiguration),
|
|
|
- machine: this
|
|
|
- });
|
|
|
- var didUpdateContext = context !== updatedContext;
|
|
|
- nextState.changed = _event.name === update || didUpdateContext;
|
|
|
- var history = nextState.history;
|
|
|
- if (history) {
|
|
|
- delete history.history;
|
|
|
- }
|
|
|
- var hasAlwaysTransitions = !isDone && (this._transient || configuration.some(function(stateNode) {
|
|
|
- return stateNode._transient;
|
|
|
- }));
|
|
|
- if (!willTransition && (!hasAlwaysTransitions || _event.name === NULL_EVENT)) {
|
|
|
- return nextState;
|
|
|
- }
|
|
|
- var maybeNextState = nextState;
|
|
|
- if (!isDone) {
|
|
|
- if (hasAlwaysTransitions) {
|
|
|
- maybeNextState = this.resolveRaisedTransition(maybeNextState, {
|
|
|
- type: nullEvent
|
|
|
- }, _event, predictableExec);
|
|
|
- }
|
|
|
- while(raisedEvents.length){
|
|
|
- var raisedEvent = raisedEvents.shift();
|
|
|
- maybeNextState = this.resolveRaisedTransition(maybeNextState, raisedEvent._event, _event, predictableExec);
|
|
|
- }
|
|
|
- }
|
|
|
- var changed = maybeNextState.changed || (history ? !!maybeNextState.actions.length || didUpdateContext || typeof history.value !== typeof maybeNextState.value || !stateValuesEqual(maybeNextState.value, history.value) : void 0);
|
|
|
- maybeNextState.changed = changed;
|
|
|
- maybeNextState.history = history;
|
|
|
- return maybeNextState;
|
|
|
- };
|
|
|
- StateNode2.prototype.getStateNode = function(stateKey) {
|
|
|
- if (isStateId(stateKey)) {
|
|
|
- return this.machine.getStateNodeById(stateKey);
|
|
|
- }
|
|
|
- if (!this.states) {
|
|
|
- throw new Error("Unable to retrieve child state '".concat(stateKey, "' from '").concat(this.id, "'; no child states exist."));
|
|
|
- }
|
|
|
- var result = this.states[stateKey];
|
|
|
- if (!result) {
|
|
|
- throw new Error("Child state '".concat(stateKey, "' does not exist on '").concat(this.id, "'"));
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- StateNode2.prototype.getStateNodeById = function(stateId) {
|
|
|
- var resolvedStateId = isStateId(stateId) ? stateId.slice(STATE_IDENTIFIER.length) : stateId;
|
|
|
- if (resolvedStateId === this.id) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- var stateNode = this.machine.idMap[resolvedStateId];
|
|
|
- if (!stateNode) {
|
|
|
- throw new Error("Child state node '#".concat(resolvedStateId, "' does not exist on machine '").concat(this.id, "'"));
|
|
|
- }
|
|
|
- return stateNode;
|
|
|
- };
|
|
|
- StateNode2.prototype.getStateNodeByPath = function(statePath) {
|
|
|
- if (typeof statePath === "string" && isStateId(statePath)) {
|
|
|
- try {
|
|
|
- return this.getStateNodeById(statePath.slice(1));
|
|
|
- } catch (e) {}
|
|
|
- }
|
|
|
- var arrayStatePath = toStatePath(statePath, this.delimiter).slice();
|
|
|
- var currentStateNode = this;
|
|
|
- while(arrayStatePath.length){
|
|
|
- var key = arrayStatePath.shift();
|
|
|
- if (!key.length) {
|
|
|
- break;
|
|
|
- }
|
|
|
- currentStateNode = currentStateNode.getStateNode(key);
|
|
|
- }
|
|
|
- return currentStateNode;
|
|
|
- };
|
|
|
- StateNode2.prototype.resolve = function(stateValue) {
|
|
|
- var _a2;
|
|
|
- var _this = this;
|
|
|
- if (!stateValue) {
|
|
|
- return this.initialStateValue || EMPTY_OBJECT;
|
|
|
- }
|
|
|
- switch(this.type){
|
|
|
- case "parallel":
|
|
|
- return mapValues(this.initialStateValue, function(subStateValue, subStateKey) {
|
|
|
- return subStateValue ? _this.getStateNode(subStateKey).resolve(stateValue[subStateKey] || subStateValue) : EMPTY_OBJECT;
|
|
|
- });
|
|
|
- case "compound":
|
|
|
- if (isString(stateValue)) {
|
|
|
- var subStateNode = this.getStateNode(stateValue);
|
|
|
- if (subStateNode.type === "parallel" || subStateNode.type === "compound") {
|
|
|
- return _a2 = {}, _a2[stateValue] = subStateNode.initialStateValue, _a2;
|
|
|
- }
|
|
|
- return stateValue;
|
|
|
- }
|
|
|
- if (!Object.keys(stateValue).length) {
|
|
|
- return this.initialStateValue || {};
|
|
|
- }
|
|
|
- return mapValues(stateValue, function(subStateValue, subStateKey) {
|
|
|
- return subStateValue ? _this.getStateNode(subStateKey).resolve(subStateValue) : EMPTY_OBJECT;
|
|
|
- });
|
|
|
- default:
|
|
|
- return stateValue || EMPTY_OBJECT;
|
|
|
- }
|
|
|
- };
|
|
|
- StateNode2.prototype.getResolvedPath = function(stateIdentifier) {
|
|
|
- if (isStateId(stateIdentifier)) {
|
|
|
- var stateNode = this.machine.idMap[stateIdentifier.slice(STATE_IDENTIFIER.length)];
|
|
|
- if (!stateNode) {
|
|
|
- throw new Error("Unable to find state node '".concat(stateIdentifier, "'"));
|
|
|
- }
|
|
|
- return stateNode.path;
|
|
|
- }
|
|
|
- return toStatePath(stateIdentifier, this.delimiter);
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "initialStateValue", {
|
|
|
- get: function() {
|
|
|
- var _a2;
|
|
|
- if (this.__cache.initialStateValue) {
|
|
|
- return this.__cache.initialStateValue;
|
|
|
- }
|
|
|
- var initialStateValue;
|
|
|
- if (this.type === "parallel") {
|
|
|
- initialStateValue = mapFilterValues(this.states, function(state) {
|
|
|
- return state.initialStateValue || EMPTY_OBJECT;
|
|
|
- }, function(stateNode) {
|
|
|
- return !(stateNode.type === "history");
|
|
|
- });
|
|
|
- } else if (this.initial !== void 0) {
|
|
|
- if (!this.states[this.initial]) {
|
|
|
- throw new Error("Initial state '".concat(this.initial, "' not found on '").concat(this.key, "'"));
|
|
|
- }
|
|
|
- initialStateValue = isLeafNode(this.states[this.initial]) ? this.initial : (_a2 = {}, _a2[this.initial] = this.states[this.initial].initialStateValue, _a2);
|
|
|
- } else {
|
|
|
- initialStateValue = {};
|
|
|
- }
|
|
|
- this.__cache.initialStateValue = initialStateValue;
|
|
|
- return this.__cache.initialStateValue;
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.getInitialState = function(stateValue, context) {
|
|
|
- this._init();
|
|
|
- var configuration = this.getStateNodes(stateValue);
|
|
|
- return this.resolveTransition({
|
|
|
- configuration,
|
|
|
- exitSet: [],
|
|
|
- transitions: [],
|
|
|
- source: void 0,
|
|
|
- actions: []
|
|
|
- }, void 0, context !== null && context !== void 0 ? context : this.machine.context, void 0);
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "initialState", {
|
|
|
- get: function() {
|
|
|
- var initialStateValue = this.initialStateValue;
|
|
|
- if (!initialStateValue) {
|
|
|
- throw new Error("Cannot retrieve initial state from simple state '".concat(this.id, "'."));
|
|
|
- }
|
|
|
- return this.getInitialState(initialStateValue);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "target", {
|
|
|
- get: function() {
|
|
|
- var target;
|
|
|
- if (this.type === "history") {
|
|
|
- var historyConfig = this.config;
|
|
|
- if (isString(historyConfig.target)) {
|
|
|
- target = isStateId(historyConfig.target) ? pathToStateValue(this.machine.getStateNodeById(historyConfig.target).path.slice(this.path.length - 1)) : historyConfig.target;
|
|
|
- } else {
|
|
|
- target = historyConfig.target;
|
|
|
- }
|
|
|
- }
|
|
|
- return target;
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.getRelativeStateNodes = function(relativeStateId, historyValue, resolve) {
|
|
|
- if (resolve === void 0) {
|
|
|
- resolve = true;
|
|
|
- }
|
|
|
- return resolve ? relativeStateId.type === "history" ? relativeStateId.resolveHistory(historyValue) : relativeStateId.initialStateNodes : [
|
|
|
- relativeStateId
|
|
|
- ];
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "initialStateNodes", {
|
|
|
- get: function() {
|
|
|
- var _this = this;
|
|
|
- if (isLeafNode(this)) {
|
|
|
- return [
|
|
|
- this
|
|
|
- ];
|
|
|
- }
|
|
|
- if (this.type === "compound" && !this.initial) {
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(false, "Compound state node '".concat(this.id, "' has no initial state."));
|
|
|
- }
|
|
|
- return [
|
|
|
- this
|
|
|
- ];
|
|
|
- }
|
|
|
- var initialStateNodePaths = toStatePaths(this.initialStateValue);
|
|
|
- return flatten(initialStateNodePaths.map(function(initialPath) {
|
|
|
- return _this.getFromRelativePath(initialPath);
|
|
|
- }));
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.getFromRelativePath = function(relativePath) {
|
|
|
- if (!relativePath.length) {
|
|
|
- return [
|
|
|
- this
|
|
|
- ];
|
|
|
- }
|
|
|
- var _a2 = __read(relativePath), stateKey = _a2[0], childStatePath = _a2.slice(1);
|
|
|
- if (!this.states) {
|
|
|
- throw new Error("Cannot retrieve subPath '".concat(stateKey, "' from node with no states"));
|
|
|
- }
|
|
|
- var childStateNode = this.getStateNode(stateKey);
|
|
|
- if (childStateNode.type === "history") {
|
|
|
- return childStateNode.resolveHistory();
|
|
|
- }
|
|
|
- if (!this.states[stateKey]) {
|
|
|
- throw new Error("Child state '".concat(stateKey, "' does not exist on '").concat(this.id, "'"));
|
|
|
- }
|
|
|
- return this.states[stateKey].getFromRelativePath(childStatePath);
|
|
|
- };
|
|
|
- StateNode2.prototype.historyValue = function(relativeStateValue) {
|
|
|
- if (!Object.keys(this.states).length) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return {
|
|
|
- current: relativeStateValue || this.initialStateValue,
|
|
|
- states: mapFilterValues(this.states, function(stateNode, key) {
|
|
|
- if (!relativeStateValue) {
|
|
|
- return stateNode.historyValue();
|
|
|
- }
|
|
|
- var subStateValue = isString(relativeStateValue) ? void 0 : relativeStateValue[key];
|
|
|
- return stateNode.historyValue(subStateValue || stateNode.initialStateValue);
|
|
|
- }, function(stateNode) {
|
|
|
- return !stateNode.history;
|
|
|
- })
|
|
|
- };
|
|
|
- };
|
|
|
- StateNode2.prototype.resolveHistory = function(historyValue) {
|
|
|
- var _this = this;
|
|
|
- if (this.type !== "history") {
|
|
|
- return [
|
|
|
- this
|
|
|
- ];
|
|
|
- }
|
|
|
- var parent = this.parent;
|
|
|
- if (!historyValue) {
|
|
|
- var historyTarget = this.target;
|
|
|
- return historyTarget ? flatten(toStatePaths(historyTarget).map(function(relativeChildPath) {
|
|
|
- return parent.getFromRelativePath(relativeChildPath);
|
|
|
- })) : parent.initialStateNodes;
|
|
|
- }
|
|
|
- var subHistoryValue = nestedPath(parent.path, "states")(historyValue).current;
|
|
|
- if (isString(subHistoryValue)) {
|
|
|
- return [
|
|
|
- parent.getStateNode(subHistoryValue)
|
|
|
- ];
|
|
|
- }
|
|
|
- return flatten(toStatePaths(subHistoryValue).map(function(subStatePath) {
|
|
|
- return _this.history === "deep" ? parent.getFromRelativePath(subStatePath) : [
|
|
|
- parent.states[subStatePath[0]]
|
|
|
- ];
|
|
|
- }));
|
|
|
- };
|
|
|
- Object.defineProperty(StateNode2.prototype, "stateIds", {
|
|
|
- get: function() {
|
|
|
- var _this = this;
|
|
|
- var childStateIds = flatten(Object.keys(this.states).map(function(stateKey) {
|
|
|
- return _this.states[stateKey].stateIds;
|
|
|
- }));
|
|
|
- return [
|
|
|
- this.id
|
|
|
- ].concat(childStateIds);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "events", {
|
|
|
- get: function() {
|
|
|
- var e_8, _a2, e_9, _b;
|
|
|
- if (this.__cache.events) {
|
|
|
- return this.__cache.events;
|
|
|
- }
|
|
|
- var states = this.states;
|
|
|
- var events = new Set(this.ownEvents);
|
|
|
- if (states) {
|
|
|
- try {
|
|
|
- for(var _c = __values(Object.keys(states)), _d = _c.next(); !_d.done; _d = _c.next()){
|
|
|
- var stateId = _d.value;
|
|
|
- var state = states[stateId];
|
|
|
- if (state.states) {
|
|
|
- try {
|
|
|
- for(var _e = (e_9 = void 0, __values(state.events)), _f = _e.next(); !_f.done; _f = _e.next()){
|
|
|
- var event_1 = _f.value;
|
|
|
- events.add("".concat(event_1));
|
|
|
- }
|
|
|
- } catch (e_9_1) {
|
|
|
- e_9 = {
|
|
|
- error: e_9_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
|
|
|
- } finally{
|
|
|
- if (e_9) throw e_9.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_8_1) {
|
|
|
- e_8 = {
|
|
|
- error: e_8_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_d && !_d.done && (_a2 = _c.return)) _a2.call(_c);
|
|
|
- } finally{
|
|
|
- if (e_8) throw e_8.error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return this.__cache.events = Array.from(events);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(StateNode2.prototype, "ownEvents", {
|
|
|
- get: function() {
|
|
|
- var events = new Set(this.transitions.filter(function(transition) {
|
|
|
- return !(!transition.target && !transition.actions.length && transition.internal);
|
|
|
- }).map(function(transition) {
|
|
|
- return transition.eventType;
|
|
|
- }));
|
|
|
- return Array.from(events);
|
|
|
- },
|
|
|
- enumerable: false,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- StateNode2.prototype.resolveTarget = function(_target) {
|
|
|
- var _this = this;
|
|
|
- if (_target === void 0) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return _target.map(function(target) {
|
|
|
- if (!isString(target)) {
|
|
|
- return target;
|
|
|
- }
|
|
|
- var isInternalTarget = target[0] === _this.delimiter;
|
|
|
- if (isInternalTarget && !_this.parent) {
|
|
|
- return _this.getStateNodeByPath(target.slice(1));
|
|
|
- }
|
|
|
- var resolvedTarget = isInternalTarget ? _this.key + target : target;
|
|
|
- if (_this.parent) {
|
|
|
- try {
|
|
|
- var targetStateNode = _this.parent.getStateNodeByPath(resolvedTarget);
|
|
|
- return targetStateNode;
|
|
|
- } catch (err) {
|
|
|
- throw new Error("Invalid transition definition for state node '".concat(_this.id, "':\n").concat(err.message));
|
|
|
- }
|
|
|
- } else {
|
|
|
- return _this.getStateNodeByPath(resolvedTarget);
|
|
|
- }
|
|
|
- });
|
|
|
- };
|
|
|
- StateNode2.prototype.formatTransition = function(transitionConfig) {
|
|
|
- var _this = this;
|
|
|
- var normalizedTarget = normalizeTarget(transitionConfig.target);
|
|
|
- var internal = "internal" in transitionConfig ? transitionConfig.internal : normalizedTarget ? normalizedTarget.some(function(_target) {
|
|
|
- return isString(_target) && _target[0] === _this.delimiter;
|
|
|
- }) : true;
|
|
|
- var guards = this.machine.options.guards;
|
|
|
- var target = this.resolveTarget(normalizedTarget);
|
|
|
- var transition = __assign(__assign({}, transitionConfig), {
|
|
|
- actions: toActionObjects(toArray(transitionConfig.actions)),
|
|
|
- cond: toGuard(transitionConfig.cond, guards),
|
|
|
- target,
|
|
|
- source: this,
|
|
|
- internal,
|
|
|
- eventType: transitionConfig.event,
|
|
|
- toJSON: function() {
|
|
|
- return __assign(__assign({}, transition), {
|
|
|
- target: transition.target ? transition.target.map(function(t2) {
|
|
|
- return "#".concat(t2.id);
|
|
|
- }) : void 0,
|
|
|
- source: "#".concat(_this.id)
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- return transition;
|
|
|
- };
|
|
|
- StateNode2.prototype.formatTransitions = function() {
|
|
|
- var e_10, _a2;
|
|
|
- var _this = this;
|
|
|
- var onConfig;
|
|
|
- if (!this.config.on) {
|
|
|
- onConfig = [];
|
|
|
- } else if (Array.isArray(this.config.on)) {
|
|
|
- onConfig = this.config.on;
|
|
|
- } else {
|
|
|
- var _b = this.config.on, _c = WILDCARD, _d = _b[_c], wildcardConfigs = _d === void 0 ? [] : _d, strictTransitionConfigs_1 = __rest(_b, [
|
|
|
- typeof _c === "symbol" ? _c : _c + ""
|
|
|
- ]);
|
|
|
- onConfig = flatten(Object.keys(strictTransitionConfigs_1).map(function(key) {
|
|
|
- if (!IS_PRODUCTION && key === NULL_EVENT) {
|
|
|
- warn(false, "Empty string transition configs (e.g., `{ on: { '': ... }}`) for transient transitions are deprecated. Specify the transition in the `{ always: ... }` property instead. " + 'Please check the `on` configuration for "#'.concat(_this.id, '".'));
|
|
|
- }
|
|
|
- var transitionConfigArray = toTransitionConfigArray(key, strictTransitionConfigs_1[key]);
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- validateArrayifiedTransitions(_this, key, transitionConfigArray);
|
|
|
- }
|
|
|
- return transitionConfigArray;
|
|
|
- }).concat(toTransitionConfigArray(WILDCARD, wildcardConfigs)));
|
|
|
- }
|
|
|
- var eventlessConfig = this.config.always ? toTransitionConfigArray("", this.config.always) : [];
|
|
|
- var doneConfig = this.config.onDone ? toTransitionConfigArray(String(done(this.id)), this.config.onDone) : [];
|
|
|
- if (!IS_PRODUCTION) {
|
|
|
- warn(!(this.config.onDone && !this.parent), 'Root nodes cannot have an ".onDone" transition. Please check the config of "'.concat(this.id, '".'));
|
|
|
- }
|
|
|
- var invokeConfig = flatten(this.invoke.map(function(invokeDef) {
|
|
|
- var settleTransitions = [];
|
|
|
- if (invokeDef.onDone) {
|
|
|
- settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(doneInvoke(invokeDef.id)), invokeDef.onDone)), false));
|
|
|
- }
|
|
|
- if (invokeDef.onError) {
|
|
|
- settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(error2(invokeDef.id)), invokeDef.onError)), false));
|
|
|
- }
|
|
|
- return settleTransitions;
|
|
|
- }));
|
|
|
- var delayedTransitions = this.after;
|
|
|
- var formattedTransitions = flatten(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(doneConfig), false), __read(invokeConfig), false), __read(onConfig), false), __read(eventlessConfig), false).map(function(transitionConfig) {
|
|
|
- return toArray(transitionConfig).map(function(transition) {
|
|
|
- return _this.formatTransition(transition);
|
|
|
- });
|
|
|
- }));
|
|
|
- try {
|
|
|
- for(var delayedTransitions_1 = __values(delayedTransitions), delayedTransitions_1_1 = delayedTransitions_1.next(); !delayedTransitions_1_1.done; delayedTransitions_1_1 = delayedTransitions_1.next()){
|
|
|
- var delayedTransition = delayedTransitions_1_1.value;
|
|
|
- formattedTransitions.push(delayedTransition);
|
|
|
- }
|
|
|
- } catch (e_10_1) {
|
|
|
- e_10 = {
|
|
|
- error: e_10_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (delayedTransitions_1_1 && !delayedTransitions_1_1.done && (_a2 = delayedTransitions_1.return)) _a2.call(delayedTransitions_1);
|
|
|
- } finally{
|
|
|
- if (e_10) throw e_10.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return formattedTransitions;
|
|
|
- };
|
|
|
- return StateNode2;
|
|
|
-}();
|
|
|
-// node_modules/xstate/es/Machine.js
|
|
|
-var warned = false;
|
|
|
-function Machine(config, options, initialContext) {
|
|
|
- if (initialContext === void 0) {
|
|
|
- initialContext = config.context;
|
|
|
- }
|
|
|
- return new StateNode(config, options, initialContext);
|
|
|
-}
|
|
|
-function createMachine(config, options) {
|
|
|
- if (!IS_PRODUCTION && !("predictableActionArguments" in config) && !warned) {
|
|
|
- warned = true;
|
|
|
- console.warn("It is highly recommended to set `predictableActionArguments` to `true` when using `createMachine`. https://xstate.js.org/docs/guides/actions.html");
|
|
|
- }
|
|
|
- return new StateNode(config, options);
|
|
|
-}
|
|
|
-// node_modules/xstate/es/mapState.js
|
|
|
-function mapState(stateMap, stateId) {
|
|
|
- var e_1, _a2;
|
|
|
- var foundStateId;
|
|
|
- try {
|
|
|
- for(var _b = __values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()){
|
|
|
- var mappedStateId = _c.value;
|
|
|
- if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
|
|
|
- foundStateId = mappedStateId;
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return stateMap[foundStateId];
|
|
|
-}
|
|
|
-// node_modules/xstate/es/match.js
|
|
|
-function matchState(state, patterns, defaultValue) {
|
|
|
- var e_1, _a2;
|
|
|
- var resolvedState = State.from(state, state instanceof State ? state.context : void 0);
|
|
|
- try {
|
|
|
- for(var patterns_1 = __values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()){
|
|
|
- var _b = __read(patterns_1_1.value, 2), stateValue = _b[0], getValue2 = _b[1];
|
|
|
- if (resolvedState.matches(stateValue)) {
|
|
|
- return getValue2(resolvedState);
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e_1_1) {
|
|
|
- e_1 = {
|
|
|
- error: e_1_1
|
|
|
- };
|
|
|
- } finally{
|
|
|
- try {
|
|
|
- if (patterns_1_1 && !patterns_1_1.done && (_a2 = patterns_1.return)) _a2.call(patterns_1);
|
|
|
- } finally{
|
|
|
- if (e_1) throw e_1.error;
|
|
|
- }
|
|
|
- }
|
|
|
- return defaultValue(resolvedState);
|
|
|
-}
|
|
|
-// node_modules/xstate/es/schema.js
|
|
|
-function createSchema(schema) {
|
|
|
- return schema;
|
|
|
-}
|
|
|
-var t = createSchema;
|
|
|
-// node_modules/xstate/es/index.js
|
|
|
-var assign3 = assign2;
|
|
|
-var cancel3 = cancel2;
|
|
|
-var send3 = send2;
|
|
|
-var sendTo2 = sendTo;
|
|
|
-var sendParent2 = sendParent;
|
|
|
-var sendUpdate2 = sendUpdate;
|
|
|
-var forwardTo2 = forwardTo;
|
|
|
-var doneInvoke2 = doneInvoke;
|
|
|
-var raise3 = raise2;
|
|
|
-var log3 = log2;
|
|
|
-var pure3 = pure2;
|
|
|
-var choose3 = choose2;
|
|
|
-var stop3 = stop2;
|
|
|
- /*! *****************************************************************************
|
|
|
-Copyright (c) Microsoft Corporation.
|
|
|
-
|
|
|
-Permission to use, copy, modify, and/or distribute this software for any
|
|
|
-purpose with or without fee is hereby granted.
|
|
|
-
|
|
|
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
|
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
|
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
|
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
|
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
|
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
-PERFORMANCE OF THIS SOFTWARE.
|
|
|
-***************************************************************************** */
|
|
|
-
|
|
|
-
|
|
|
-/***/ })
|
|
|
-
|
|
|
-}]);
|