@logicflow/engine 0.0.1 → 0.0.3

package/es/Scheduler.d.ts

@@ -1,25 +1,40 @@
 import EventEmitter from './EventEmitter';
-import type { TaskParam, NodeParam, ResumeParam } from './types.d';
+import type { ActionParam, NodeParam, ResumeParam } from './types.d';
 import type FlowModel from './FlowModel';
 import type Recorder from './recorder';
-declare type TaskParamMap = Map<string, TaskParam>;
+declare type ActionParamMap = Map<string, ActionParam>;
+declare type ExecutionId = string;
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
  */
 export default class Scheduler extends EventEmitter {
-    nodeQueueMap: Map<string, NodeParam[]>;
-    taskRunningMap: Map<string, TaskParamMap>;
+    /**
+     * 当前需要执行的节点队列
+     */
+    nodeQueueMap: Map<ExecutionId, NodeParam[]>;
+    /**
+     * 当前正在执行的节点集合
+     * 在每个节点执行完成后，会从集合中删除。
+     * 同时会判断此集合中是否还存在和此节点相同的executionId，如果不存在，说明此流程已经执行完成。
+     */
+    actionRunningMap: Map<ExecutionId, ActionParamMap>;
+    /**
+     * 流程模型，用于创建节点模型。
+     */
     flowModel: FlowModel;
+    /**
+     * 执行记录存储器
+     * 用于存储节点执行的结果。
+     */
     recorder: Recorder;
-    currentTask: TaskParam | null;
     constructor(config: any);
     /**
      * 添加一个任务到队列中。
      * 1. 由流程模型将所有的开始节点添加到队列中。
      * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    addTask(nodeParam: NodeParam): void;
+    addAction(nodeParam: NodeParam): void;
     /**
      * 调度器执行下一个任务
      * 1. 提供给流程模型，用户开始执行第一个任务。
@@ -29,23 +44,19 @@ export default class Scheduler extends EventEmitter {
     run(runParams: {
         executionId: string;
         nodeId?: string;
-        taskId?: string;
+        actionId?: string;
     }): void;
     /**
      * 恢复某个任务的执行。
      * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
      */
     resume(resumeParam: ResumeParam): Promise<void>;
-    stop(data: any): void;
-    private pushTaskToRunningMap;
-    private removeTaskFromRunningMap;
-    private hasRunningTask;
+    private pushActionToRunningMap;
+    private removeActionFromRunningMap;
+    private hasRunningAction;
     private exec;
     private interrupted;
     private next;
-    /**
-     * 为了防止多次添加导致
-     */
-    private saveTaskResult;
+    private saveActionResult;
 }
 export {};

package/es/Scheduler.js

@@ -60,7 +60,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import EventEmitter from './EventEmitter';
 import { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, FlowStatus, } from './constant/constant';
-import { createTaskId } from './util/ID';
+import { createActionId } from './util/ID';
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
@@ -70,10 +70,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;
     }
     /**
@@ -81,13 +80,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);
     };
     /**
      * 调度器执行下一个任务
@@ -97,22 +96,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 = createTaskId();
-                var taskParam = __assign(__assign({}, currentNode), { taskId: taskId });
-                this.pushTaskToRunningMap(taskParam);
-                this.exec(taskParam);
-            }
+        // 将同一个executionId当前待执行的节点一起执行
+        // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长。
+        while (nodeQueue.length) {
+            var currentNode = nodeQueue.pop();
+            var actionId = 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(EVENT_INSTANCE_COMPLETE, {
                 executionId: runParams.executionId,
                 nodeId: runParams.nodeId,
-                taskId: runParams.taskId,
+                actionId: runParams.actionId,
                 status: FlowStatus.COMPLETED,
             });
         }
@@ -127,12 +125,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();
@@ -141,48 +139,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:
@@ -190,12 +184,12 @@ var Scheduler = /** @class */ (function (_super) {
                         if (execResult && execResult.status === 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: [],
@@ -204,7 +198,7 @@ var Scheduler = /** @class */ (function (_super) {
                                     detail: execResult.detail,
                                 },
                             });
-                            this.removeTaskFromRunningMap(taskParam);
+                            this.removeActionFromRunningMap(actionParam);
                         }
                         return [2 /*return*/];
                 }
@@ -212,63 +206,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(EVENT_INSTANCE_INTERRUPTED, {
-            executionId: taskParam.executionId,
+            executionId: actionParam.executionId,
             status: 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/es/constant/constant.d.ts

@@ -7,7 +7,7 @@ export declare enum FlowStatus {
     RUNNING = "running",
     ERROR = "error"
 }
-export declare enum TaskStatus {
+export declare enum ActionStatus {
     SUCCESS = "success",
     ERROR = "error",
     INTERRUPTED = "interrupted"

package/es/constant/constant.js

@@ -11,10 +11,10 @@ export var FlowStatus;
     FlowStatus["RUNNING"] = "running";
     FlowStatus["ERROR"] = "error";
 })(FlowStatus || (FlowStatus = {}));
-// task status
-export var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["SUCCESS"] = "success";
-    TaskStatus["ERROR"] = "error";
-    TaskStatus["INTERRUPTED"] = "interrupted";
-})(TaskStatus || (TaskStatus = {}));
+// action status
+export var ActionStatus;
+(function (ActionStatus) {
+    ActionStatus["SUCCESS"] = "success";
+    ActionStatus["ERROR"] = "error";
+    ActionStatus["INTERRUPTED"] = "interrupted";
+})(ActionStatus || (ActionStatus = {}));

package/es/expression/browserVm.d.ts

@@ -1,2 +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, };
+export { runInBrowserContext, createContext, runInContext, };

package/es/expression/browserVm.js

@@ -35,32 +35,38 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 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));
+    }
+    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);
+    }
+    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 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(getErrorMsg(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(getWarningMsg(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];
         });
     });
 };
-export { runInBrowserContext, };
+export { runInBrowserContext, createContext, runInContext, };

package/es/expression/nodeVm.js

@@ -34,7 +34,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-// import vm from 'node:vm';
+/* eslint-disable global-require */
 var vm = require('vm');
 var runInNewContext = function (code, globalData) {
     if (globalData === void 0) { globalData = {}; }

package/es/index.d.ts

@@ -1,18 +1,21 @@
-import type { ResumeParams, GraphConfigData } from './types.d';
-import FlowModel, { TaskParams } from './FlowModel';
+import type { ResumeParams, GraphConfigData, EngineConstructorOptions } from './types.d';
+import FlowModel, { ActionParams } from './FlowModel';
 import StartNode from './nodes/StartNode';
 import TaskNode from './nodes/TaskNode';
 import Recorder from './recorder';
+import { NodeConstructor } from './nodes/BaseNode';
 export default class Engine {
+    id: string;
     global: Record<string, any>;
     graphData: GraphConfigData;
-    nodeModelMap: Map<string, any>;
+    nodeModelMap: Map<string, NodeConstructor>;
     flowModel: FlowModel;
     recorder: Recorder;
-    constructor();
+    context: Record<string, any>;
+    constructor(options?: EngineConstructorOptions);
     /**
      * 注册节点
-     * @param nodeConfig { type: 'custom-node', model: Class }
+     * @param nodeConfig { type: 'custom-node', model: NodeClass }
      */
     register(nodeConfig: any): void;
     /**
@@ -20,8 +23,8 @@ export default class Engine {
      * 注意：由于执行记录不会主动删除，所以需要自行清理。
      * nodejs环境建议自定义为持久化存储。
      * engine.setCustomRecorder({
-     *   async addTask(task) {}
-     *   async getTask(taskId) {}
+     *   async addActionRecord(task) {}
+     *   async getTask(actionId) {}
      *   async getExecutionTasks(executionId) {}
      *   clear() {}
      * });
@@ -30,18 +33,26 @@ export default class Engine {
     /**
      * 加载流程图数据
      */
-    load({ graphData, startNodeType, globalData, context, }: {
+    load({ graphData, startNodeType, globalData, }: {
         graphData: any;
         startNodeType?: string;
         globalData?: {};
-        context?: {};
     }): FlowModel;
     /**
      * 执行流程，允许多次调用。
      */
-    execute(execParam?: TaskParams): Promise<unknown>;
+    execute(execParam?: ActionParams): Promise<unknown>;
+    /**
+     * 恢复执行
+     * 注意此方法只能恢复节点后面的执行，不能恢复流程其他分支的执行。
+     * 同理，中断执行也只能中断节点后面的执行，不会中断其他分支的执行。
+     * 在实际项目中，如果存在中断节点，建议流程所有的节点都是排他网关，这样可以保证执行的过程不存在分支。
+     */
     resume(resumeParam: ResumeParams): Promise<unknown>;
     getExecutionRecord(executionId: any): Promise<any[]>;
+    getGlobalData(): Record<string, any>;
+    setGlobalData(data: any): void;
+    updateGlobalData(data: any): void;
 }
 export { Engine, TaskNode, StartNode, };
-export type { TaskParams, };
+export type { ActionParams, };

package/es/index.js

@@ -49,11 +49,12 @@ import FlowModel from './FlowModel';
 import StartNode from './nodes/StartNode';
 import TaskNode from './nodes/TaskNode';
 import Recorder from './recorder';
+import { createEngineId } from './util/ID';
 var Engine = /** @class */ (function () {
-    function Engine() {
+    function Engine(options) {
         this.nodeModelMap = new Map();
+        this.id = createEngineId();
         this.recorder = new Recorder();
-        // register node
         this.register({
             type: StartNode.nodeTypeName,
             model: StartNode,
@@ -62,10 +63,11 @@ var Engine = /** @class */ (function () {
             type: TaskNode.nodeTypeName,
             model: TaskNode,
         });
+        this.context = (options === null || options === void 0 ? void 0 : options.context) || {};
     }
     /**
      * 注册节点
-     * @param nodeConfig { type: 'custom-node', model: Class }
+     * @param nodeConfig { type: 'custom-node', model: NodeClass }
      */
     Engine.prototype.register = function (nodeConfig) {
         this.nodeModelMap.set(nodeConfig.type, nodeConfig.model);
@@ -75,8 +77,8 @@ var Engine = /** @class */ (function () {
      * 注意：由于执行记录不会主动删除，所以需要自行清理。
      * nodejs环境建议自定义为持久化存储。
      * engine.setCustomRecorder({
-     *   async addTask(task) {}
-     *   async getTask(taskId) {}
+     *   async addActionRecord(task) {}
+     *   async getTask(actionId) {}
      *   async getExecutionTasks(executionId) {}
      *   clear() {}
      * });
@@ -88,11 +90,11 @@ var Engine = /** @class */ (function () {
      * 加载流程图数据
      */
     Engine.prototype.load = function (_a) {
-        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c, _d = _a.context, context = _d === void 0 ? {} : _d;
+        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c;
         this.flowModel = new FlowModel({
             nodeModelMap: this.nodeModelMap,
             recorder: this.recorder,
-            context: context,
+            context: this.context,
             globalData: globalData,
             startNodeType: startNodeType,
         });
@@ -119,6 +121,12 @@ var Engine = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 恢复执行
+     * 注意此方法只能恢复节点后面的执行，不能恢复流程其他分支的执行。
+     * 同理，中断执行也只能中断节点后面的执行，不会中断其他分支的执行。
+     * 在实际项目中，如果存在中断节点，建议流程所有的节点都是排他网关，这样可以保证执行的过程不存在分支。
+     */
     Engine.prototype.resume = function (resumeParam) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
@@ -138,18 +146,35 @@ var Engine = /** @class */ (function () {
             var tasks, records, i;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.recorder.getExecutionTasks(executionId)];
+                    case 0: return [4 /*yield*/, this.recorder.getExecutionActions(executionId)];
                     case 1:
                         tasks = _a.sent();
+                        if (!tasks) {
+                            return [2 /*return*/, null];
+                        }
                         records = [];
                         for (i = 0; i < tasks.length; i++) {
-                            records.push(this.recorder.getTask(tasks[i]));
+                            records.push(this.recorder.getActionRecord(tasks[i]));
                         }
                         return [2 /*return*/, Promise.all(records)];
                 }
             });
         });
     };
+    Engine.prototype.getGlobalData = function () {
+        var _a;
+        return (_a = this.flowModel) === null || _a === void 0 ? void 0 : _a.globalData;
+    };
+    Engine.prototype.setGlobalData = function (data) {
+        if (this.flowModel) {
+            this.flowModel.globalData = data;
+        }
+    };
+    Engine.prototype.updateGlobalData = function (data) {
+        if (this.flowModel) {
+            Object.assign(this.flowModel.globalData, data);
+        }
+    };
     return Engine;
 }());
 export default Engine;