@logicflow/engine 0.0.10-beta.0 → 0.0.11-beta.0

package/es/Scheduler.js

@@ -1,66 +1,158 @@
-import { __awaiter } from "tslib";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        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))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import EventEmitter from './EventEmitter';
-import { createActionId } from './utils';
-import { EVENT_INSTANCE_ERROR, EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, FlowStatus, } from './constant';
+import { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, EVENT_INSTANCE_ERROR, FlowStatus, } from './constant/constant';
+import { createActionId } from './util/ID';
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
  */
-export class Scheduler extends EventEmitter {
-    constructor(config) {
-        super();
-        this.nodeQueueMap = new Map();
-        this.actionRunningMap = new Map();
-        this.flowModel = config.flowModel;
-        this.recorder = config.recorder;
+var Scheduler = /** @class */ (function (_super) {
+    __extends(Scheduler, _super);
+    function Scheduler(config) {
+        var _this = _super.call(this) || this;
+        _this.nodeQueueMap = new Map();
+        _this.actionRunningMap = new Map();
+        _this.flowModel = config.flowModel;
+        _this.recorder = config.recorder;
+        return _this;
     }
     /**
      * 添加一个任务到队列中。
-     * 1. 由流程模型将所有的开始及诶带你添加到队列中
-     * 2. 当一个节点执行完成后，将后续的节点添加到队列中
-     * @param nodeParam
+     * 1. 由流程模型将所有的开始节点添加到队列中。
+     * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    addAction(nodeParam) {
-        const { executionId } = nodeParam;
+    Scheduler.prototype.addAction = function (nodeParam) {
+        var executionId = nodeParam.executionId;
         if (!this.nodeQueueMap.has(executionId)) {
             this.nodeQueueMap.set(executionId, []);
         }
-        const currentActionQueue = this.nodeQueueMap.get(executionId);
-        if (currentActionQueue) {
-            currentActionQueue.push(nodeParam);
+        var currentActionQueue = this.nodeQueueMap.get(executionId);
+        currentActionQueue.push(nodeParam);
+    };
+    /**
+     * 调度器执行下一个任务
+     * 1. 提供给流程模型，用户开始执行第一个任务。
+     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务。
+     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件。
+     */
+    Scheduler.prototype.run = function (runParams) {
+        var nodeQueue = this.nodeQueueMap.get(runParams.executionId);
+        // 将同一个executionId当前待执行的节点一起执行
+        // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长。
+        while (nodeQueue.length) {
+            var currentNode = nodeQueue.pop();
+            var actionId = createActionId();
+            var actionParam = __assign(__assign({}, currentNode), { actionId: actionId });
+            this.pushActionToRunningMap(actionParam);
+            this.exec(actionParam);
         }
-        console.log('this.nodeQueueMap--->>>', this.nodeQueueMap);
-    }
-    pushActionToRunningMap(actionParam) {
-        var _a;
-        const { executionId, actionId } = actionParam;
+        if (!this.hasRunningAction(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和actionRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+            this.emit(EVENT_INSTANCE_COMPLETE, __assign(__assign({}, runParams), { status: FlowStatus.COMPLETED }));
+        }
+    };
+    /**
+     * 恢复某个任务的执行。
+     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
+     */
+    Scheduler.prototype.resume = function (resumeParam) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.pushActionToRunningMap({
+                            executionId: resumeParam.executionId,
+                            nodeId: resumeParam.nodeId,
+                            actionId: resumeParam.actionId,
+                        });
+                        model = this.flowModel.createAction(resumeParam.nodeId);
+                        return [4 /*yield*/, model.resume(__assign(__assign({}, resumeParam), { next: this.next.bind(this) }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scheduler.prototype.pushActionToRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
         if (!this.actionRunningMap.has(executionId)) {
-            const runningMap = new Map();
+            var runningMap = new Map();
             this.actionRunningMap.set(executionId, runningMap);
         }
-        if (actionId) {
-            (_a = this.actionRunningMap.get(executionId)) === null || _a === void 0 ? void 0 : _a.set(actionId, actionParam);
-        }
-    }
-    removeActionFromRunningMap(actionParam) {
-        const { executionId, actionId } = actionParam;
+        this.actionRunningMap.get(executionId).set(actionId, actionParam);
+    };
+    Scheduler.prototype.removeActionFromRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
         if (!actionId)
             return;
-        const runningMap = this.actionRunningMap.get(executionId);
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return;
         runningMap.delete(actionId);
-    }
-    /**
-     * 为了防止多次添加导致
-     * @param actionParam
-     */
-    saveActionResult(actionParam) {
-        var _a;
-        (_a = this.recorder) === null || _a === void 0 ? void 0 : _a.addActionRecord(Object.assign({ timestamp: Date.now() }, actionParam));
-    }
-    hasRunningAction(executionId) {
-        const runningMap = this.actionRunningMap.get(executionId);
+    };
+    Scheduler.prototype.hasRunningAction = function (executionId) {
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return false;
         if (runningMap.size === 0) {
@@ -68,35 +160,67 @@ export class Scheduler extends EventEmitter {
             return false;
         }
         return true;
-    }
-    /**
-     * 调度器执行下一个任务
-     * 1. 提供给流程模型，用户开始执行第一个任务
-     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务
-     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件
-     * @param runParam
-     */
-    run(runParam) {
-        const nodeQueue = this.nodeQueueMap.get(runParam.executionId);
-        // 将同一个 executionId 当前待执行的节点一起执行
-        // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长
-        while (nodeQueue === null || nodeQueue === void 0 ? void 0 : nodeQueue.length) {
-            const currentNode = nodeQueue.pop();
-            const actionId = createActionId();
-            const actionParam = Object.assign(Object.assign({}, currentNode), { actionId });
-            this.pushActionToRunningMap(actionParam);
-            this.exec(actionParam);
-        }
-        if (!this.hasRunningAction(runParam.executionId)) {
-            // 当一个流程在 nodeQueueMap 和 actionRunningMap 中都不存在执行的节点时，说明这个流程已经执行完成。
-            this.emit(EVENT_INSTANCE_COMPLETE, Object.assign(Object.assign({}, runParam), { status: FlowStatus.COMPLETED }));
-        }
-    }
-    next(data) {
+    };
+    Scheduler.prototype.exec = function (actionParam) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model, execResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        model = this.flowModel.createAction(actionParam.nodeId);
+                        return [4 /*yield*/, model.execute({
+                                executionId: actionParam.executionId,
+                                actionId: actionParam.actionId,
+                                nodeId: actionParam.nodeId,
+                                next: this.next.bind(this),
+                            })];
+                    case 1:
+                        execResult = _a.sent();
+                        if (execResult && execResult.status === FlowStatus.INTERRUPTED) {
+                            this.interrupted(execResult);
+                            this.saveActionResult({
+                                executionId: actionParam.executionId,
+                                nodeId: actionParam.nodeId,
+                                actionId: actionParam.actionId,
+                                nodeType: execResult.nodeType,
+                                properties: execResult.properties,
+                                outgoing: execResult.outgoing,
+                                status: execResult.status,
+                                detail: execResult.detail,
+                            });
+                            this.removeActionFromRunningMap(actionParam);
+                        }
+                        if (execResult && execResult.status === FlowStatus.ERROR) {
+                            this.error(execResult);
+                            this.saveActionResult({
+                                executionId: actionParam.executionId,
+                                nodeId: actionParam.nodeId,
+                                actionId: actionParam.actionId,
+                                nodeType: execResult.nodeType,
+                                properties: execResult.properties,
+                                outgoing: execResult.outgoing,
+                                status: execResult.status,
+                                detail: execResult.detail,
+                            });
+                            this.removeActionFromRunningMap(actionParam);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scheduler.prototype.interrupted = function (execResult) {
+        this.emit(EVENT_INSTANCE_INTERRUPTED, execResult);
+    };
+    Scheduler.prototype.error = function (execResult) {
+        this.emit(EVENT_INSTANCE_ERROR, execResult);
+    };
+    Scheduler.prototype.next = function (data) {
+        var _this = this;
         if (data.outgoing && data.outgoing.length > 0) {
-            data.outgoing.forEach((item) => {
+            data.outgoing.forEach(function (item) {
                 if (item.result) {
-                    this.addAction({
+                    _this.addAction({
                         executionId: data.executionId,
                         nodeId: item.target,
                     });
@@ -106,70 +230,21 @@ export class Scheduler extends EventEmitter {
         this.saveActionResult(data);
         this.removeActionFromRunningMap(data);
         this.run(data);
-    }
-    /**
-     * 恢复某个任务的执行
-     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行
-     * @param resumeParam
-     */
-    resume(resumeParam) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { executionId, actionId, nodeId } = resumeParam;
-            this.pushActionToRunningMap({
-                executionId,
-                actionId,
-                nodeId,
-            });
-            const model = this.flowModel.createAction(nodeId);
-            yield (model === null || model === void 0 ? void 0 : model.resume(Object.assign(Object.assign({}, resumeParam), { next: this.next.bind(this) })));
-        });
-    }
-    // 中断时，触发事件
-    interrupted(execResult) {
-        this.emit(EVENT_INSTANCE_INTERRUPTED, execResult);
-    }
-    // 报错时，触发事件
-    error(execResult) {
-        this.emit(EVENT_INSTANCE_ERROR, execResult);
-    }
-    exec(actionParam) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { executionId, actionId, nodeId } = actionParam;
-            const model = this.flowModel.createAction(nodeId);
-            const execResult = yield (model === null || model === void 0 ? void 0 : model.execute({
-                executionId,
-                actionId,
-                nodeId,
-                next: this.next.bind(this),
-            }));
-            if (execResult) {
-                const { nodeType, properties, outgoing, status, detail } = execResult;
-                const actionResult = {
-                    // actionParam
-                    executionId,
-                    actionId,
-                    nodeId,
-                    // execResult
-                    nodeType,
-                    properties,
-                    outgoing,
-                    status,
-                    detail,
-                };
-                if ((execResult === null || execResult === void 0 ? void 0 : execResult.status) === FlowStatus.INTERRUPTED) {
-                    this.interrupted(execResult);
-                    this.saveActionResult(actionResult);
-                    this.removeActionFromRunningMap(actionParam);
-                }
-                if ((execResult === null || execResult === void 0 ? void 0 : execResult.status) === FlowStatus.ERROR) {
-                    this.error(execResult);
-                    this.saveActionResult(actionResult);
-                    this.removeActionFromRunningMap(actionParam);
-                }
-            }
-            // TODO: 考虑停下所有的任务
+    };
+    Scheduler.prototype.saveActionResult = function (data) {
+        var _a;
+        (_a = this.recorder) === null || _a === void 0 ? void 0 : _a.addActionRecord({
+            executionId: data.executionId,
+            actionId: data.actionId,
+            nodeId: data.nodeId,
+            nodeType: data.nodeType,
+            timestamp: Date.now(),
+            properties: data.properties,
+            outgoing: data.outgoing,
+            detail: data.detail,
+            status: data.status,
         });
-    }
-}
+    };
+    return Scheduler;
+}(EventEmitter));
 export default Scheduler;
-//# sourceMappingURL=Scheduler.js.map

package/es/constant/LogCode.js

@@ -0,0 +1,28 @@
+var _a, _b;
+export var ErrorCode;
+(function (ErrorCode) {
+    // 模型数据错误
+    ErrorCode[ErrorCode["NONE_START_NODE"] = 1000] = "NONE_START_NODE";
+    ErrorCode[ErrorCode["NONE_NODE_ID"] = 1001] = "NONE_NODE_ID";
+    // 表达式错误
+    ErrorCode[ErrorCode["NO_DOCUMENT_BODY"] = 2001] = "NO_DOCUMENT_BODY";
+})(ErrorCode || (ErrorCode = {}));
+export var WarningCode;
+(function (WarningCode) {
+    WarningCode[WarningCode["NONE_START_NODE_IN_DATA"] = 2000] = "NONE_START_NODE_IN_DATA";
+    WarningCode[WarningCode["START_NODE_INCOMING"] = 2001] = "START_NODE_INCOMING";
+    // 表达式判断异常
+    WarningCode[WarningCode["EXPRESSION_EXEC_ERROR"] = 3000] = "EXPRESSION_EXEC_ERROR";
+})(WarningCode || (WarningCode = {}));
+var errorMsgMapCn = (_a = {},
+    _a[ErrorCode.NONE_START_NODE] = '未找到入度为0的节点',
+    _a[ErrorCode.NONE_NODE_ID] = '流程数据中存在没有此节点',
+    _a[ErrorCode.NO_DOCUMENT_BODY] = '找不到document.body, 请在DOM加载完成后再执行',
+    _a);
+var warningMsgMapCn = (_b = {},
+    _b[WarningCode.NONE_START_NODE_IN_DATA] = '初始化数据中未找到入度为0的节点',
+    _b[WarningCode.START_NODE_INCOMING] = '开始节点不允许被连入',
+    _b[WarningCode.EXPRESSION_EXEC_ERROR] = '表达式执行异常',
+    _b);
+export var getErrorMsg = function (code) { return "error[" + code + "]: " + errorMsgMapCn[code]; };
+export var getWarningMsg = function (code) { return "warning[" + code + "]: " + warningMsgMapCn[code]; };

package/es/constant/{index.js → constant.js}

@@ -1,10 +1,10 @@
 // baseType
-export const BASE_START_NODE = 'start';
-// eventType
-export const EVENT_INSTANCE_COMPLETE = 'instance:complete';
-export const EVENT_INSTANCE_INTERRUPTED = 'instance:interrupted';
-export const EVENT_INSTANCE_ERROR = 'instance:error';
-// flowStatus
+export var BASE_START_NODE = 'start';
+// event name
+export var EVENT_INSTANCE_COMPLETE = 'instance:complete';
+export var EVENT_INSTANCE_INTERRUPTED = 'instance:interrupted';
+export var EVENT_INSTANCE_ERROR = 'instance:error';
+// flow status
 export var FlowStatus;
 (function (FlowStatus) {
     FlowStatus["COMPLETED"] = "completed";
@@ -13,11 +13,10 @@ export var FlowStatus;
     FlowStatus["PENDING"] = "pending";
     FlowStatus["ERROR"] = "error";
 })(FlowStatus || (FlowStatus = {}));
-// actionStatus
+// action status
 export var ActionStatus;
 (function (ActionStatus) {
     ActionStatus["SUCCESS"] = "success";
     ActionStatus["ERROR"] = "error";
     ActionStatus["INTERRUPTED"] = "interrupted";
 })(ActionStatus || (ActionStatus = {}));
-//# sourceMappingURL=index.js.map

package/es/expression/browserVm.d.ts

@@ -0,0 +1,4 @@
+declare const createContext: (globalData: any) => any;
+declare const runInContext: (code: any, context: any) => any;
+declare const runInBrowserContext: (code: string, globalData?: any) => Promise<any>;
+export { runInBrowserContext, createContext, runInContext, };

package/es/expression/browserVm.js

@@ -0,0 +1,76 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { ErrorCode, WarningCode, getErrorMsg, getWarningMsg, } from '../constant/LogCode';
+var createContext = function (globalData) {
+    var iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    if (!document || !document.body) {
+        console.error(getErrorMsg(ErrorCode.NO_DOCUMENT_BODY));
+    }
+    document.body.appendChild(iframe);
+    var iframeWindow = iframe.contentWindow;
+    iframeWindow.parent = null;
+    Object.keys(globalData).forEach(function (key) {
+        iframeWindow[key] = globalData[key];
+    });
+    return iframeWindow;
+};
+var runInContext = function (code, context) {
+    try {
+        var iframeEval = context.eval;
+        iframeEval.call(context, code);
+        if (context.frameElement) {
+            document.body.removeChild(context.frameElement);
+        }
+    }
+    catch (e) {
+        console.warn(getWarningMsg(WarningCode.EXPRESSION_EXEC_ERROR), { code: code, context: context, e: e });
+    }
+    return context;
+};
+var runInBrowserContext = function (code, globalData) {
+    if (globalData === void 0) { globalData = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var context;
+        return __generator(this, function (_a) {
+            context = createContext(globalData);
+            runInContext(code, context);
+            return [2 /*return*/, context];
+        });
+    });
+};
+export { runInBrowserContext, createContext, runInContext, };

package/es/expression/index.d.ts

@@ -1,2 +1,2 @@
 declare const getExpressionResult: (code: string, context: any) => Promise<any>;
-export { getExpressionResult };
+export { getExpressionResult, };

package/es/expression/index.js

@@ -1,17 +1,54 @@
-import { __awaiter } from "tslib";
-import { runInNodeContext } from './nodeVm';
-import { runInBrowserContext } from './brewserVm';
-import { isInNodeJS, isInBrowser, globalScope } from '../utils';
-const getExpressionResult = (code, context) => __awaiter(void 0, void 0, void 0, function* () {
-    if (isInNodeJS) {
-        const r = yield runInNodeContext(code, context);
-        return r;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-    if (isInBrowser) {
-        const r = yield runInBrowserContext(code, context);
-        return r;
-    }
-    return globalScope.eval(code);
-});
-export { getExpressionResult };
-//# sourceMappingURL=index.js.map
+};
+// import { runInNewContext } from './nodeVm';
+import { runInBrowserContext } from './browserVm';
+import { isInBrowser, globalScope } from '../util/global';
+var getExpressionResult = function (code, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var r;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!isInBrowser) return [3 /*break*/, 2];
+                return [4 /*yield*/, runInBrowserContext(code, context)];
+            case 1:
+                r = _a.sent();
+                return [2 /*return*/, r];
+            case 2: return [2 /*return*/, globalScope.eval(code)]; // eslint-disable-line no-eval
+        }
+    });
+}); };
+export { getExpressionResult, };