@logicflow/engine 0.0.1

package/es/Scheduler.js

@@ -0,0 +1,276 @@
+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 { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, FlowStatus, } from './constant/constant';
+import { createTaskId } from './util/ID';
+/**
+ * 调度器
+ * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
+ */
+var Scheduler = /** @class */ (function (_super) {
+    __extends(Scheduler, _super);
+    function Scheduler(config) {
+        var _this = _super.call(this) || this;
+        _this.nodeQueueMap = new Map();
+        _this.taskRunningMap = new Map();
+        _this.flowModel = config.flowModel;
+        _this.recorder = config.recorder;
+        _this.currentTask = null;
+        return _this;
+    }
+    /**
+     * 添加一个任务到队列中。
+     * 1. 由流程模型将所有的开始节点添加到队列中。
+     * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
+     */
+    Scheduler.prototype.addTask = function (nodeParam) {
+        var executionId = nodeParam.executionId;
+        if (!this.nodeQueueMap.has(executionId)) {
+            this.nodeQueueMap.set(executionId, []);
+        }
+        var currentTaskQueue = this.nodeQueueMap.get(executionId);
+        currentTaskQueue.push(nodeParam);
+    };
+    /**
+     * 调度器执行下一个任务
+     * 1. 提供给流程模型，用户开始执行第一个任务。
+     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务。
+     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件。
+     */
+    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);
+            }
+        }
+        else if (!this.hasRunningTask(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和taskRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+            this.emit(EVENT_INSTANCE_COMPLETE, {
+                executionId: runParams.executionId,
+                nodeId: runParams.nodeId,
+                taskId: runParams.taskId,
+                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.pushTaskToRunningMap({
+                            executionId: resumeParam.executionId,
+                            nodeId: resumeParam.nodeId,
+                            taskId: resumeParam.taskId,
+                        });
+                        model = this.flowModel.createTask(resumeParam.nodeId);
+                        return [4 /*yield*/, model.resume(__assign(__assign({}, resumeParam), { next: this.next.bind(this) }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 流程执行过程中出错，停止执行
+    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)) {
+            var runningMap = new Map();
+            this.taskRunningMap.set(executionId, runningMap);
+        }
+        this.taskRunningMap.get(executionId).set(taskId, taskParam);
+    };
+    Scheduler.prototype.removeTaskFromRunningMap = function (taskParam) {
+        var executionId = taskParam.executionId, taskId = taskParam.taskId;
+        if (!taskId)
+            return;
+        var runningMap = this.taskRunningMap.get(executionId);
+        if (!runningMap)
+            return;
+        runningMap.delete(taskId);
+    };
+    Scheduler.prototype.hasRunningTask = function (executionId) {
+        var runningMap = this.taskRunningMap.get(executionId);
+        if (!runningMap)
+            return false;
+        if (runningMap.size === 0) {
+            this.taskRunningMap.delete(executionId);
+            return false;
+        }
+        return true;
+    };
+    Scheduler.prototype.exec = function (taskParam) {
+        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);
+                        return [4 /*yield*/, model.execute({
+                                executionId: taskParam.executionId,
+                                taskId: taskParam.taskId,
+                                nodeId: taskParam.nodeId,
+                                next: this.next.bind(this),
+                            })];
+                    case 1:
+                        execResult = _a.sent();
+                        if (execResult && execResult.status === FlowStatus.INTERRUPTED) {
+                            this.interrupted({
+                                execResult: execResult,
+                                taskParam: taskParam,
+                            });
+                            this.saveTaskResult({
+                                executionId: taskParam.executionId,
+                                nodeId: taskParam.nodeId,
+                                taskId: taskParam.taskId,
+                                nodeType: execResult.nodeType,
+                                properties: execResult.properties,
+                                outgoing: [],
+                                extraInfo: {
+                                    status: execResult.status,
+                                    detail: execResult.detail,
+                                },
+                            });
+                            this.removeTaskFromRunningMap(taskParam);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Scheduler.prototype.interrupted = function (_a) {
+        var execResult = _a.execResult, taskParam = _a.taskParam;
+        this.emit(EVENT_INSTANCE_INTERRUPTED, {
+            executionId: taskParam.executionId,
+            status: FlowStatus.INTERRUPTED,
+            nodeId: taskParam.nodeId,
+            taskId: taskParam.taskId,
+            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*/];
+                }
+            });
+        });
+    };
+    /**
+     * 为了防止多次添加导致
+     */
+    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*/];
+                }
+            });
+        });
+    };
+    return Scheduler;
+}(EventEmitter));
+export default Scheduler;

package/es/constant/LogCode.d.ts

@@ -0,0 +1,12 @@
+export declare enum ErrorCode {
+    NONE_START_NODE = 1000,
+    NONE_NODE_ID = 1001,
+    NO_DOCUMENT_BODY = 2001
+}
+export declare enum WarningCode {
+    NONE_START_NODE_IN_DATA = 2000,
+    START_NODE_INCOMING = 2001,
+    EXPRESSION_EXEC_ERROR = 3000
+}
+export declare const getErrorMsg: (code: ErrorCode) => string;
+export declare const getWarningMsg: (code: WarningCode) => string;

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/constant.d.ts

@@ -0,0 +1,14 @@
+export declare const BASE_START_NODE = "start";
+export declare const EVENT_INSTANCE_COMPLETE = "instance:complete";
+export declare const EVENT_INSTANCE_INTERRUPTED = "instance:interrupted";
+export declare enum FlowStatus {
+    COMPLETED = "completed",
+    INTERRUPTED = "interrupted",
+    RUNNING = "running",
+    ERROR = "error"
+}
+export declare enum TaskStatus {
+    SUCCESS = "success",
+    ERROR = "error",
+    INTERRUPTED = "interrupted"
+}

package/es/constant/constant.js

@@ -0,0 +1,20 @@
+// baseType
+export var BASE_START_NODE = 'start';
+// event name
+export var EVENT_INSTANCE_COMPLETE = 'instance:complete';
+export var EVENT_INSTANCE_INTERRUPTED = 'instance:interrupted';
+// flow status
+export var FlowStatus;
+(function (FlowStatus) {
+    FlowStatus["COMPLETED"] = "completed";
+    FlowStatus["INTERRUPTED"] = "interrupted";
+    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 = {}));

package/es/expression/browserVm.d.ts

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

package/es/expression/browserVm.js

@@ -0,0 +1,66 @@
+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 runInBrowserContext = function (code, globalData) {
+    if (globalData === void 0) { globalData = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var iframe, iframeWindow, iframeEval, res;
+        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];
+        });
+    });
+};
+export { runInBrowserContext, };

package/es/expression/index.d.ts

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

package/es/expression/index.js

@@ -0,0 +1,60 @@
+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 { runInNewContext } from './nodeVm';
+import { runInBrowserContext } from './browserVm';
+import { isInNodeJS, isInBrowser, globalScope } from '../util/global';
+var getExpressionResult = function (code, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var r, r;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!isInNodeJS) return [3 /*break*/, 2];
+                return [4 /*yield*/, runInNewContext(code, context)];
+            case 1:
+                r = _a.sent();
+                return [2 /*return*/, r];
+            case 2:
+                if (!isInBrowser) return [3 /*break*/, 4];
+                return [4 /*yield*/, runInBrowserContext(code, context)];
+            case 3:
+                r = _a.sent();
+                return [2 /*return*/, r];
+            case 4: return [2 /*return*/, globalScope.eval(code)]; // eslint-disable-line no-eval
+        }
+    });
+}); };
+export { getExpressionResult, };

package/es/expression/nodeVm.d.ts

@@ -0,0 +1,2 @@
+declare const runInNewContext: (code: string, globalData?: any) => Promise<any>;
+export { runInNewContext, };

package/es/expression/nodeVm.js

@@ -0,0 +1,50 @@
+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 vm from 'node:vm';
+var vm = require('vm');
+var runInNewContext = 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 = vm.createContext(globalData);
+            vm.runInContext(code, context);
+            return [2 /*return*/, context];
+        });
+    });
+};
+export { runInNewContext, };

package/es/index.d.ts

@@ -0,0 +1,47 @@
+import type { ResumeParams, GraphConfigData } from './types.d';
+import FlowModel, { TaskParams } from './FlowModel';
+import StartNode from './nodes/StartNode';
+import TaskNode from './nodes/TaskNode';
+import Recorder from './recorder';
+export default class Engine {
+    global: Record<string, any>;
+    graphData: GraphConfigData;
+    nodeModelMap: Map<string, any>;
+    flowModel: FlowModel;
+    recorder: Recorder;
+    constructor();
+    /**
+     * 注册节点
+     * @param nodeConfig { type: 'custom-node', model: Class }
+     */
+    register(nodeConfig: any): void;
+    /**
+     * 自定义执行记录的存储，默认浏览器使用 sessionStorage，nodejs 使用内存存储。
+     * 注意：由于执行记录不会主动删除，所以需要自行清理。
+     * nodejs环境建议自定义为持久化存储。
+     * engine.setCustomRecorder({
+     *   async addTask(task) {}
+     *   async getTask(taskId) {}
+     *   async getExecutionTasks(executionId) {}
+     *   clear() {}
+     * });
+     */
+    setCustomRecorder(recorder: Recorder): void;
+    /**
+     * 加载流程图数据
+     */
+    load({ graphData, startNodeType, globalData, context, }: {
+        graphData: any;
+        startNodeType?: string;
+        globalData?: {};
+        context?: {};
+    }): FlowModel;
+    /**
+     * 执行流程，允许多次调用。
+     */
+    execute(execParam?: TaskParams): Promise<unknown>;
+    resume(resumeParam: ResumeParams): Promise<unknown>;
+    getExecutionRecord(executionId: any): Promise<any[]>;
+}
+export { Engine, TaskNode, StartNode, };
+export type { TaskParams, };