@logicflow/engine 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [0.0.3](https://github.com/didi/LogicFlow/compare/@logicflow/engine@0.0.2...@logicflow/engine@0.0.3) (2023-08-18)
+
+
+### Bug Fixes
+
+* **engine:** build error when use es-module ([3fbd88a](https://github.com/didi/LogicFlow/commit/3fbd88a8279602b907ab6f3e3a6353a46f64ee8c))
+* **engine:** support es module umd and commonJs ([bb17159](https://github.com/didi/LogicFlow/commit/bb171597725b78b28cc2ad74350ab7728e580158))
+
+
+
+
+
+## 0.0.2 (2023-08-10)
+
+
+### Bug Fixes
+
+* **engine:** consistent expression evaluation in browser and nodejs ([8f24045](https://github.com/didi/LogicFlow/commit/8f240451dce588b6fa21e639c79e1a0782937ff9))
+
+
+### Features
+
+* add support for specifying the start node and multiple executions ([113ad88](https://github.com/didi/LogicFlow/commit/113ad880cdb564431933eeeed3b661c50fca2a9c))
+* added expression evaluation functionality for Node.js and browser ([a7759f6](https://github.com/didi/LogicFlow/commit/a7759f69d4f7b294397c8502da654ea7c729d930))
+* create logicflow eninge ([c7d80f4](https://github.com/didi/LogicFlow/commit/c7d80f4b4c19cf82af9be49dd8fd44433327db58))
+* **engie:** support parallel execution within workflows ([8e17ea6](https://github.com/didi/LogicFlow/commit/8e17ea614c5c3567e532a67240cf8e0e9110b2bf))
+* **engine:** add comments and sync storage execution ([6fa0904](https://github.com/didi/LogicFlow/commit/6fa0904ddee88254d4af5c246ff0247c988dfdd2))
+* **engine:** add the ability to pause and resume workflows ([7c4e385](https://github.com/didi/LogicFlow/commit/7c4e3855ad0a7af4121de6552be61f690b4e0e6c))
+* **engine:** added workflow scheduling feature ([c2a7044](https://github.com/didi/LogicFlow/commit/c2a704449772445387f324924491f15e526dfc4e))
+* implemented execution record query functionality ([d73aa46](https://github.com/didi/LogicFlow/commit/d73aa46675f35bae5362e6024232d44cbfe5bcaa))

package/README.md

@@ -4,19 +4,7 @@
 
 ## 使用方式
 
-```js
-import LogicFlowEngine from '@logicflow/engine';
-
-const flowModel = new LogicFlowEngine({
-  graphData: {
-    nodes: [],
-    edges: [],
-  },
-  global: {
-    // 全局数据
-  }
-});
-
-flowModel.execute();
-
+```shell
+npm test
 ```
+

package/cjs/FlowModel.js

@@ -70,7 +70,7 @@ var FlowModel = /** @class */ (function () {
         // 流程包含的节点类型
         this.nodeModelMap = nodeModelMap;
         // 需要执行的队列
-        this.executeQueue = [];
+        this.executeList = [];
         // 执行中的任务
         this.executingInstance = null;
         // 外部传入的上下文，最终会传递给每个节点
@@ -85,18 +85,53 @@ var FlowModel = /** @class */ (function () {
             recorder: recorder,
         });
         this.scheduler.on(constant_1.EVENT_INSTANCE_COMPLETE, function (result) {
-            _this.onTaskFinished(result);
+            _this.onExecuteFinished(result);
         });
         this.scheduler.on(constant_1.EVENT_INSTANCE_INTERRUPTED, function (result) {
-            _this.onTaskFinished(result);
+            _this.onExecuteFinished(result);
         });
     }
     FlowModel.prototype.setStartNodeType = function (startNodeType) {
         this.startNodeType = startNodeType;
     };
+    /**
+     * 解析LogicFlow图数据，将nodes和edges转换成节点格式。
+     * 例如：
+     * graphData: {
+     *  nodes: [
+     *   { id: 'node1', type: 'StartNode', properties: {} },
+     *   { id: 'node2', type: 'TaskNode', properties: {} },
+     *  ],
+     *  edges: [
+     *    { id: 'edge1', sourceNodeId: 'node1', targetNodeId: 'node2', properties: {} },
+     *  ]
+     * }
+     * 转换成：
+     * nodeConfigMap: {
+     *  node1: {
+     *    id: 'node1',
+     *    type: 'StartNode',
+     *    properties: {},
+     *    incoming: [],
+     *    outgoing: [{ id: 'edge1', properties: {}, target: 'node2' }]
+     *  },
+     *  node2: {
+     *   id: 'node2',
+     *   type: 'TaskNode',
+     *   properties: {},
+     *   incoming: [{ id: 'edge1', properties: {}, source: 'node1' }],
+     *   outgoing: [],
+     *  }
+     * }
+     * 此格式方便后续执行时，根据节点id快速找到节点和执行初始化节点模型。
+     * 同时此方法还会找到所有的开始节点，方便后续执行时，从开始节点开始执行。
+     * @param graphData 流程图数据
+     */
     FlowModel.prototype.load = function (graphData) {
         var _this = this;
         var _a = graphData.nodes, nodes = _a === void 0 ? [] : _a, _b = graphData.edges, edges = _b === void 0 ? [] : _b;
+        this.startNodes = [];
+        this.nodeConfigMap = new Map();
         nodes.forEach(function (node) {
             if (_this.nodeModelMap.has(node.type)) {
                 var nodeConfig = {
@@ -135,24 +170,19 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
-     * 例如：
+     * 执行流程, 每次执行都会生成一个唯一的executionId，用于区分不同的执行。
+     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行。
+     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
+     * example：
      * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
      * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
      * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
+     * TODO: 去掉此处的对列，直接使用调度器的队列。
      */
     FlowModel.prototype.execute = function (params) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                this.executeQueue.push(params);
-                if (this.isRunning) {
-                    return [2 /*return*/];
-                }
-                this.isRunning = true;
-                this.createExecution();
+                this.createExecution(params);
                 return [2 /*return*/];
             });
         });
@@ -160,30 +190,26 @@ var FlowModel = /** @class */ (function () {
     FlowModel.prototype.resume = function (params) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                this.executeQueue.push(params);
-                if (this.isRunning) {
-                    return [2 /*return*/];
-                }
-                this.isRunning = true;
-                this.createExecution();
+                this.createExecution(params);
                 return [2 /*return*/];
             });
         });
     };
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
-    FlowModel.prototype.createTask = function (nodeId) {
+    FlowModel.prototype.createAction = function (nodeId) {
         var nodeConfig = this.nodeConfigMap.get(nodeId);
         var NodeModel = this.nodeModelMap.get(nodeConfig.type);
-        var task = new NodeModel({
+        var action = new NodeModel({
             nodeConfig: nodeConfig,
             globalData: this.globalData,
             context: this.context,
         });
-        return task;
+        return action;
     };
     /**
      * 更新流程全局数据
@@ -191,43 +217,40 @@ var FlowModel = /** @class */ (function () {
     FlowModel.prototype.updateGlobalData = function (data) {
         this.globalData = __assign(__assign({}, this.globalData), data);
     };
-    FlowModel.prototype.onTaskFinished = function (result) {
-        var executionId = result.executionId;
-        if (executionId !== this.executionId) {
-            return;
-        }
-        var callback = this.executingInstance.callback;
-        if (callback) {
-            callback(result);
-        }
-        this.executingInstance = null;
-        if (this.executeQueue.length > 0) {
-            this.createExecution();
-        }
-        else {
-            this.isRunning = false;
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
+    FlowModel.prototype.onExecuteFinished = function (result) {
+        var index = this.executeList.findIndex(function (i) { return i.executionId === result.executionId; });
+        if (index !== -1) {
+            var callback = this.executeList[index].callback;
+            this.executeList.splice(index, 1);
+            callback && callback(result);
         }
     };
-    FlowModel.prototype.createExecution = function () {
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
+    FlowModel.prototype.createExecution = function (execParams) {
         var _this = this;
-        var execParams = this.executeQueue.shift();
-        this.executingInstance = execParams;
-        if (execParams.executionId) {
-            this.executionId = execParams.executionId;
-        }
-        else {
-            this.executionId = ID_1.createExecId();
-        }
+        this.executeList.push(execParams);
         // 如果有taskId，那么表示恢复执行
-        if (execParams.taskId) {
+        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
-                executionId: this.executionId,
-                taskId: execParams.taskId,
+                executionId: execParams.executionId,
+                actionId: execParams.actionId,
                 nodeId: execParams.nodeId,
                 data: execParams.data,
             });
             return;
         }
+        var executionId = ID_1.createExecId();
+        execParams.executionId = executionId;
         if (execParams.nodeId) {
             var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
@@ -237,14 +260,13 @@ var FlowModel = /** @class */ (function () {
             this.startNodes = [nodeConfig];
         }
         this.startNodes.forEach(function (startNode) {
-            _this.scheduler.addTask({
-                executionId: _this.executionId,
+            _this.scheduler.addAction({
+                executionId: executionId,
                 nodeId: startNode.id,
             });
-            // 所有的开始节点都执行
         });
         this.scheduler.run({
-            executionId: this.executionId,
+            executionId: executionId,
         });
     };
     return FlowModel;

package/cjs/Scheduler.js

@@ -72,10 +72,9 @@ var Scheduler = /** @class */ (function (_super) {
     function Scheduler(config) {
         var _this = _super.call(this) || this;
         _this.nodeQueueMap = new Map();
-        _this.taskRunningMap = new Map();
+        _this.actionRunningMap = new Map();
         _this.flowModel = config.flowModel;
         _this.recorder = config.recorder;
-        _this.currentTask = null;
         return _this;
     }
     /**
@@ -83,13 +82,13 @@ var Scheduler = /** @class */ (function (_super) {
      * 1. 由流程模型将所有的开始节点添加到队列中。
      * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    Scheduler.prototype.addTask = function (nodeParam) {
+    Scheduler.prototype.addAction = function (nodeParam) {
         var executionId = nodeParam.executionId;
         if (!this.nodeQueueMap.has(executionId)) {
             this.nodeQueueMap.set(executionId, []);
         }
-        var currentTaskQueue = this.nodeQueueMap.get(executionId);
-        currentTaskQueue.push(nodeParam);
+        var currentActionQueue = this.nodeQueueMap.get(executionId);
+        currentActionQueue.push(nodeParam);
     };
     /**
      * 调度器执行下一个任务
@@ -99,22 +98,21 @@ var Scheduler = /** @class */ (function (_super) {
      */
     Scheduler.prototype.run = function (runParams) {
         var nodeQueue = this.nodeQueueMap.get(runParams.executionId);
-        if (nodeQueue.length > 0) {
-            this.nodeQueueMap.set(runParams.executionId, []);
-            for (var i = 0; i < nodeQueue.length; i++) {
-                var currentNode = nodeQueue[i];
-                var taskId = ID_1.createTaskId();
-                var taskParam = __assign(__assign({}, currentNode), { taskId: taskId });
-                this.pushTaskToRunningMap(taskParam);
-                this.exec(taskParam);
-            }
+        // 将同一个executionId当前待执行的节点一起执行
+        // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长。
+        while (nodeQueue.length) {
+            var currentNode = nodeQueue.pop();
+            var actionId = ID_1.createActionId();
+            var actionParam = __assign(__assign({}, currentNode), { actionId: actionId });
+            this.pushActionToRunningMap(actionParam);
+            this.exec(actionParam);
         }
-        else if (!this.hasRunningTask(runParams.executionId)) {
-            // 当一个流程在nodeQueueMap和taskRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+        if (!this.hasRunningAction(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和actionRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
             this.emit(constant_1.EVENT_INSTANCE_COMPLETE, {
                 executionId: runParams.executionId,
                 nodeId: runParams.nodeId,
-                taskId: runParams.taskId,
+                actionId: runParams.actionId,
                 status: constant_1.FlowStatus.COMPLETED,
             });
         }
@@ -129,12 +127,12 @@ var Scheduler = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this.pushTaskToRunningMap({
+                        this.pushActionToRunningMap({
                             executionId: resumeParam.executionId,
                             nodeId: resumeParam.nodeId,
-                            taskId: resumeParam.taskId,
+                            actionId: resumeParam.actionId,
                         });
-                        model = this.flowModel.createTask(resumeParam.nodeId);
+                        model = this.flowModel.createAction(resumeParam.nodeId);
                         return [4 /*yield*/, model.resume(__assign(__assign({}, resumeParam), { next: this.next.bind(this) }))];
                     case 1:
                         _a.sent();
@@ -143,48 +141,44 @@ var Scheduler = /** @class */ (function (_super) {
             });
         });
     };
-    // 流程执行过程中出错，停止执行
-    Scheduler.prototype.stop = function (data) {
-        console.log('stop', data);
-    };
-    Scheduler.prototype.pushTaskToRunningMap = function (taskParam) {
-        var executionId = taskParam.executionId, taskId = taskParam.taskId;
-        if (!this.taskRunningMap.has(executionId)) {
+    Scheduler.prototype.pushActionToRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
+        if (!this.actionRunningMap.has(executionId)) {
             var runningMap = new Map();
-            this.taskRunningMap.set(executionId, runningMap);
+            this.actionRunningMap.set(executionId, runningMap);
         }
-        this.taskRunningMap.get(executionId).set(taskId, taskParam);
+        this.actionRunningMap.get(executionId).set(actionId, actionParam);
     };
-    Scheduler.prototype.removeTaskFromRunningMap = function (taskParam) {
-        var executionId = taskParam.executionId, taskId = taskParam.taskId;
-        if (!taskId)
+    Scheduler.prototype.removeActionFromRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
+        if (!actionId)
             return;
-        var runningMap = this.taskRunningMap.get(executionId);
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return;
-        runningMap.delete(taskId);
+        runningMap.delete(actionId);
     };
-    Scheduler.prototype.hasRunningTask = function (executionId) {
-        var runningMap = this.taskRunningMap.get(executionId);
+    Scheduler.prototype.hasRunningAction = function (executionId) {
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return false;
         if (runningMap.size === 0) {
-            this.taskRunningMap.delete(executionId);
+            this.actionRunningMap.delete(executionId);
             return false;
         }
         return true;
     };
-    Scheduler.prototype.exec = function (taskParam) {
+    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.createTask(taskParam.nodeId);
+                        model = this.flowModel.createAction(actionParam.nodeId);
                         return [4 /*yield*/, model.execute({
-                                executionId: taskParam.executionId,
-                                taskId: taskParam.taskId,
-                                nodeId: taskParam.nodeId,
+                                executionId: actionParam.executionId,
+                                actionId: actionParam.actionId,
+                                nodeId: actionParam.nodeId,
                                 next: this.next.bind(this),
                             })];
                     case 1:
@@ -192,12 +186,12 @@ var Scheduler = /** @class */ (function (_super) {
                         if (execResult && execResult.status === constant_1.FlowStatus.INTERRUPTED) {
                             this.interrupted({
                                 execResult: execResult,
-                                taskParam: taskParam,
+                                actionParam: actionParam,
                             });
-                            this.saveTaskResult({
-                                executionId: taskParam.executionId,
-                                nodeId: taskParam.nodeId,
-                                taskId: taskParam.taskId,
+                            this.saveActionResult({
+                                executionId: actionParam.executionId,
+                                nodeId: actionParam.nodeId,
+                                actionId: actionParam.actionId,
                                 nodeType: execResult.nodeType,
                                 properties: execResult.properties,
                                 outgoing: [],
@@ -206,7 +200,7 @@ var Scheduler = /** @class */ (function (_super) {
                                     detail: execResult.detail,
                                 },
                             });
-                            this.removeTaskFromRunningMap(taskParam);
+                            this.removeActionFromRunningMap(actionParam);
                         }
                         return [2 /*return*/];
                 }
@@ -214,63 +208,41 @@ var Scheduler = /** @class */ (function (_super) {
         });
     };
     Scheduler.prototype.interrupted = function (_a) {
-        var execResult = _a.execResult, taskParam = _a.taskParam;
+        var execResult = _a.execResult, actionParam = _a.actionParam;
         this.emit(constant_1.EVENT_INSTANCE_INTERRUPTED, {
-            executionId: taskParam.executionId,
+            executionId: actionParam.executionId,
             status: constant_1.FlowStatus.INTERRUPTED,
-            nodeId: taskParam.nodeId,
-            taskId: taskParam.taskId,
+            nodeId: actionParam.nodeId,
+            actionId: actionParam.actionId,
             detail: execResult.detail,
         });
     };
     Scheduler.prototype.next = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (data.outgoing && data.outgoing.length > 0) {
-                            data.outgoing.forEach(function (item) {
-                                _this.addTask({
-                                    executionId: data.executionId,
-                                    nodeId: item.target,
-                                });
-                            });
-                        }
-                        return [4 /*yield*/, this.saveTaskResult(data)];
-                    case 1:
-                        _a.sent();
-                        this.removeTaskFromRunningMap(data);
-                        this.run({
-                            executionId: data.executionId,
-                            nodeId: data.nodeId,
-                            taskId: data.taskId,
-                        });
-                        return [2 /*return*/];
-                }
+        var _this = this;
+        if (data.outgoing && data.outgoing.length > 0) {
+            data.outgoing.forEach(function (item) {
+                _this.addAction({
+                    executionId: data.executionId,
+                    nodeId: item.target,
+                });
             });
+        }
+        this.saveActionResult(data);
+        this.removeActionFromRunningMap(data);
+        this.run({
+            executionId: data.executionId,
+            nodeId: data.nodeId,
+            actionId: data.actionId,
         });
     };
-    /**
-     * 为了防止多次添加导致
-     */
-    Scheduler.prototype.saveTaskResult = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.recorder.addTask({
-                            executionId: data.executionId,
-                            taskId: data.taskId,
-                            nodeId: data.nodeId,
-                            nodeType: data.nodeType,
-                            timestamp: Date.now(),
-                            properties: data.properties,
-                        })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    Scheduler.prototype.saveActionResult = function (data) {
+        this.recorder.addActionRecord({
+            executionId: data.executionId,
+            actionId: data.actionId,
+            nodeId: data.nodeId,
+            nodeType: data.nodeType,
+            timestamp: Date.now(),
+            properties: data.properties,
         });
     };
     return Scheduler;

package/cjs/constant/constant.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskStatus = exports.FlowStatus = exports.EVENT_INSTANCE_INTERRUPTED = exports.EVENT_INSTANCE_COMPLETE = exports.BASE_START_NODE = void 0;
+exports.ActionStatus = exports.FlowStatus = exports.EVENT_INSTANCE_INTERRUPTED = exports.EVENT_INSTANCE_COMPLETE = exports.BASE_START_NODE = void 0;
 // baseType
 exports.BASE_START_NODE = 'start';
 // event name
@@ -14,10 +14,10 @@ var FlowStatus;
     FlowStatus["RUNNING"] = "running";
     FlowStatus["ERROR"] = "error";
 })(FlowStatus = exports.FlowStatus || (exports.FlowStatus = {}));
-// task status
-var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["SUCCESS"] = "success";
-    TaskStatus["ERROR"] = "error";
-    TaskStatus["INTERRUPTED"] = "interrupted";
-})(TaskStatus = exports.TaskStatus || (exports.TaskStatus = {}));
+// action status
+var ActionStatus;
+(function (ActionStatus) {
+    ActionStatus["SUCCESS"] = "success";
+    ActionStatus["ERROR"] = "error";
+    ActionStatus["INTERRUPTED"] = "interrupted";
+})(ActionStatus = exports.ActionStatus || (exports.ActionStatus = {}));

package/cjs/expression/browserVm.js

@@ -36,33 +36,41 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runInBrowserContext = void 0;
+exports.runInContext = exports.createContext = exports.runInBrowserContext = void 0;
 var LogCode_1 = require("../constant/LogCode");
+var createContext = function (globalData) {
+    var iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    if (!document || !document.body) {
+        console.error(LogCode_1.getErrorMsg(LogCode_1.ErrorCode.NO_DOCUMENT_BODY));
+    }
+    var iframeWindow = iframe.contentWindow;
+    iframeWindow.parent = null;
+    Object.keys(globalData).forEach(function (key) {
+        iframeWindow[key] = globalData[key];
+    });
+    return iframeWindow;
+};
+exports.createContext = createContext;
+var runInContext = function (code, context) {
+    try {
+        var iframeEval = context.eval;
+        iframeEval.call(context, code);
+    }
+    catch (e) {
+        console.warn(LogCode_1.getWarningMsg(LogCode_1.WarningCode.EXPRESSION_EXEC_ERROR), { code: code, context: context, e: e });
+    }
+    return context;
+};
+exports.runInContext = runInContext;
 var runInBrowserContext = function (code, globalData) {
     if (globalData === void 0) { globalData = {}; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var iframe, iframeWindow, iframeEval, res;
+        var context;
         return __generator(this, function (_a) {
-            iframe = document.createElement('iframe');
-            iframe.style.display = 'none';
-            if (!document || !document.body) {
-                console.error(LogCode_1.getErrorMsg(LogCode_1.ErrorCode.NO_DOCUMENT_BODY));
-            }
-            document.body.appendChild(iframe);
-            iframeWindow = iframe.contentWindow;
-            iframeEval = iframeWindow.eval;
-            Object.keys(globalData).forEach(function (key) {
-                iframeWindow[key] = globalData[key];
-            });
-            res = null;
-            try {
-                res = iframeEval.call(iframeWindow, code);
-            }
-            catch (e) {
-                console.warn(LogCode_1.getWarningMsg(LogCode_1.WarningCode.EXPRESSION_EXEC_ERROR), { code: code, globalData: globalData, e: e });
-            }
-            document.body.removeChild(iframe);
-            return [2 /*return*/, res];
+            context = createContext(globalData);
+            runInContext(code, context);
+            return [2 /*return*/, context];
         });
     });
 };

package/cjs/expression/nodeVm.js

@@ -37,7 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runInNewContext = void 0;
-// import vm from 'node:vm';
+/* eslint-disable global-require */
 var vm = require('vm');
 var runInNewContext = function (code, globalData) {
     if (globalData === void 0) { globalData = {}; }