@logicflow/engine 0.0.10 → 0.0.11-beta.0

package/README.md

@@ -1,13 +1,10 @@
-# @logicflow/engine
+# engine
 
 一个可以在JavaScript环境执行的流程引擎
 
 ## 使用方式
 
 ```shell
-pnpm run test
+npm test
 ```
 
-## 参考资料
-![package.json 中 browser. module, main 字段优先级](https://github.com/SunshowerC/blog/issues/8)
-![编写兼容 nodejs/浏览器的库](https://blog.rxliuli.com/p/b8a95af9134a488e9d94463bd18768c9/)

package/cjs/EventEmitter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var EventEmitter = /** @class */ (function () {
+    function EventEmitter() {
+        this._events = {};
+    }
+    EventEmitter.prototype.on = function (evKey, callback, once) {
+        if (once === void 0) { once = false; }
+        evKey = evKey.trim();
+        if (!this._events[evKey]) {
+            this._events[evKey] = [];
+        }
+        this._events[evKey].push({
+            callback: callback,
+            once: !!once,
+        });
+    };
+    EventEmitter.prototype.emit = function (evt, eventArgs) {
+        var _this = this;
+        var events = this._events[evt] || [];
+        // 实际的处理 emit 方法
+        var doEmit = function (es) {
+            var length = es.length;
+            for (var i = 0; i < length; i++) {
+                if (!es[i]) {
+                    // eslint-disable-next-line no-continue
+                    continue;
+                }
+                var _a = es[i], callback = _a.callback, once = _a.once;
+                if (once) {
+                    es.splice(i, 1);
+                    if (es.length === 0) {
+                        delete _this._events[evt];
+                    }
+                    length--;
+                    i--;
+                }
+                callback.apply(_this, [eventArgs]);
+            }
+        };
+        doEmit(events);
+    };
+    EventEmitter.prototype.off = function (evt, callback) {
+        if (!evt) {
+            // evt 为空全部清除
+            this._events = {};
+        }
+        if (!callback) {
+            // evt 存在，callback 为空，清除事件所有方法
+            delete this._events[evt];
+        }
+        else {
+            // evt 存在，callback 存在，清除匹配的
+            var events = this._events[evt] || [];
+            var length_1 = events.length;
+            for (var i = 0; i < length_1; i++) {
+                if (events[i].callback === callback) {
+                    events.splice(i, 1);
+                    length_1--;
+                    i--;
+                }
+            }
+            if (events.length === 0) {
+                delete this._events[evt];
+            }
+        }
+    };
+    return EventEmitter;
+}());
+exports.default = EventEmitter;

package/cjs/FlowModel.js

@@ -0,0 +1,277 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var constant_1 = require("./constant/constant");
+var ID_1 = require("./util/ID");
+var Scheduler_1 = require("./Scheduler");
+var LogCode_1 = require("./constant/LogCode");
+var FlowModel = /** @class */ (function () {
+    function FlowModel(_a) {
+        var _this = this;
+        var nodeModelMap = _a.nodeModelMap, recorder = _a.recorder, _b = _a.context, context = _b === void 0 ? {} : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c, _d = _a.startNodeType, startNodeType = _d === void 0 ? 'StartNode' : _d;
+        /**
+         * 当前流程模型中的所有节点，边会被转换成节点的incoming和outgoing属性。
+         */
+        this.nodeConfigMap = new Map();
+        /**
+         * 当前流程中开始节点组成的数组。
+         */
+        this.startNodes = [];
+        /**
+         * 用于存储全局数据，可以在流程中共享。
+         */
+        this.globalData = {};
+        // 流程包含的节点类型
+        this.nodeModelMap = nodeModelMap;
+        // 需要执行的队列
+        this.executeList = [];
+        // 执行中的任务
+        this.executingInstance = null;
+        // 外部传入的上下文，最终会传递给每个节点
+        this.context = context;
+        // 用于存储全局数据，可以在流程中共享。
+        this.globalData = globalData;
+        // 开始节点类型，在执行流程时，会从这些节点开始执行。
+        this.startNodeType = startNodeType;
+        this.isRunning = false;
+        this.scheduler = new Scheduler_1.default({
+            flowModel: this,
+            recorder: recorder,
+        });
+        this.scheduler.on(constant_1.EVENT_INSTANCE_COMPLETE, function (result) {
+            _this.onExecuteFinished(result);
+        });
+        this.scheduler.on(constant_1.EVENT_INSTANCE_INTERRUPTED, function (result) {
+            _this.onExecuteFinished(result);
+        });
+        this.scheduler.on(constant_1.EVENT_INSTANCE_ERROR, function (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 = {
+                    id: node.id,
+                    type: node.type,
+                    properties: node.properties,
+                    incoming: [],
+                    outgoing: [],
+                };
+                _this.nodeConfigMap.set(node.id, nodeConfig);
+                if (node.type === _this.startNodeType) {
+                    _this.startNodes.push(nodeConfig);
+                }
+            }
+            else {
+                console.warn("\u672A\u8BC6\u522B\u7684\u8282\u70B9\u7C7B\u578B: " + node.type);
+            }
+        });
+        edges.forEach(function (edge) {
+            var sourceNode = _this.nodeConfigMap.get(edge.sourceNodeId);
+            var targetNode = _this.nodeConfigMap.get(edge.targetNodeId);
+            if (sourceNode) {
+                sourceNode.outgoing.push({
+                    id: edge.id,
+                    properties: edge.properties,
+                    target: edge.targetNodeId,
+                });
+            }
+            if (targetNode && targetNode.type !== _this.startNodeType) {
+                targetNode.incoming.push({
+                    id: edge.id,
+                    properties: edge.properties,
+                    source: edge.sourceNodeId,
+                });
+            }
+        });
+    };
+    /**
+     * 执行流程, 每次执行都会生成一个唯一的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.createExecution(params);
+                return [2 /*return*/];
+            });
+        });
+    };
+    FlowModel.prototype.resume = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.createExecution(params);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
+     * @param nodeId 节点Id
+     * @returns 节点示例
+     */
+    FlowModel.prototype.createAction = function (nodeId) {
+        var nodeConfig = this.nodeConfigMap.get(nodeId);
+        var NodeModel = this.nodeModelMap.get(nodeConfig.type);
+        var action = new NodeModel({
+            nodeConfig: nodeConfig,
+            globalData: this.globalData,
+            context: this.context,
+        });
+        return action;
+    };
+    /**
+     * 更新流程全局数据
+     */
+    FlowModel.prototype.updateGlobalData = function (data) {
+        this.globalData = __assign(__assign({}, this.globalData), data);
+    };
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
+    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);
+        }
+    };
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
+    FlowModel.prototype.createExecution = function (execParams) {
+        var _this = this;
+        this.executeList.push(execParams);
+        // 如果有taskId，那么表示恢复执行
+        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
+            this.scheduler.resume({
+                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) {
+                execParams.onError(new Error(LogCode_1.getErrorMsg(LogCode_1.ErrorCode.NONE_NODE_ID) + "(" + execParams.nodeId + ")"));
+                return;
+            }
+            this.startNodes = [nodeConfig];
+        }
+        this.startNodes.forEach(function (startNode) {
+            _this.scheduler.addAction({
+                executionId: executionId,
+                nodeId: startNode.id,
+            });
+        });
+        this.scheduler.run({
+            executionId: executionId,
+        });
+    };
+    return FlowModel;
+}());
+exports.default = FlowModel;

package/cjs/Scheduler.js

@@ -0,0 +1,252 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var EventEmitter_1 = require("./EventEmitter");
+var constant_1 = require("./constant/constant");
+var ID_1 = require("./util/ID");
+/**
+ * 调度器
+ * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
+ */
+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. 当一个节点执行完成后，将后续的节点添加到队列中。
+     */
+    Scheduler.prototype.addAction = function (nodeParam) {
+        var executionId = nodeParam.executionId;
+        if (!this.nodeQueueMap.has(executionId)) {
+            this.nodeQueueMap.set(executionId, []);
+        }
+        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 = ID_1.createActionId();
+            var actionParam = __assign(__assign({}, currentNode), { actionId: actionId });
+            this.pushActionToRunningMap(actionParam);
+            this.exec(actionParam);
+        }
+        if (!this.hasRunningAction(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和actionRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+            this.emit(constant_1.EVENT_INSTANCE_COMPLETE, __assign(__assign({}, runParams), { status: constant_1.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)) {
+            var runningMap = new Map();
+            this.actionRunningMap.set(executionId, runningMap);
+        }
+        this.actionRunningMap.get(executionId).set(actionId, actionParam);
+    };
+    Scheduler.prototype.removeActionFromRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
+        if (!actionId)
+            return;
+        var runningMap = this.actionRunningMap.get(executionId);
+        if (!runningMap)
+            return;
+        runningMap.delete(actionId);
+    };
+    Scheduler.prototype.hasRunningAction = function (executionId) {
+        var runningMap = this.actionRunningMap.get(executionId);
+        if (!runningMap)
+            return false;
+        if (runningMap.size === 0) {
+            this.actionRunningMap.delete(executionId);
+            return false;
+        }
+        return true;
+    };
+    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 === constant_1.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 === constant_1.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(constant_1.EVENT_INSTANCE_INTERRUPTED, execResult);
+    };
+    Scheduler.prototype.error = function (execResult) {
+        this.emit(constant_1.EVENT_INSTANCE_ERROR, execResult);
+    };
+    Scheduler.prototype.next = function (data) {
+        var _this = this;
+        if (data.outgoing && data.outgoing.length > 0) {
+            data.outgoing.forEach(function (item) {
+                if (item.result) {
+                    _this.addAction({
+                        executionId: data.executionId,
+                        nodeId: item.target,
+                    });
+                }
+            });
+        }
+        this.saveActionResult(data);
+        this.removeActionFromRunningMap(data);
+        this.run(data);
+    };
+    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_1.default));
+exports.default = Scheduler;

package/{lib/constant/logCode.js → cjs/constant/LogCode.js}

@@ -1,4 +1,5 @@
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWarningMsg = exports.getErrorMsg = exports.WarningCode = exports.ErrorCode = void 0;
 var ErrorCode;
@@ -16,19 +17,15 @@ var WarningCode;
     // 表达式判断异常
     WarningCode[WarningCode["EXPRESSION_EXEC_ERROR"] = 3000] = "EXPRESSION_EXEC_ERROR";
 })(WarningCode = exports.WarningCode || (exports.WarningCode = {}));
-// TODO: 感觉这块可以用个国际化插件，这样配置不同语言加文件就可以了。
-const errorMsgMapCn = {
-    [ErrorCode.NONE_START_NODE]: '未找到入度为0的节点',
-    [ErrorCode.NONE_NODE_ID]: '流程数据中存在没有此节点',
-    [ErrorCode.NO_DOCUMENT_BODY]: '找不到document.body, 请在DOM加载完成后再执行',
-};
-const warningMsgMapCn = {
-    [WarningCode.NONE_START_NODE_IN_DATA]: '初始化数据中未找到入度为0的节点',
-    [WarningCode.START_NODE_INCOMING]: '开始节点不允许被连入',
-    [WarningCode.EXPRESSION_EXEC_ERROR]: '表达式执行异常',
-};
-const getErrorMsg = (code) => `error[${code}]: ${errorMsgMapCn[code]}`;
-exports.getErrorMsg = getErrorMsg;
-const getWarningMsg = (code) => `warning[${code}]: ${warningMsgMapCn[code]}`;
-exports.getWarningMsg = getWarningMsg;
-//# sourceMappingURL=logCode.js.map
+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);
+exports.getErrorMsg = function (code) { return "error[" + code + "]: " + errorMsgMapCn[code]; };
+exports.getWarningMsg = function (code) { return "warning[" + code + "]: " + warningMsgMapCn[code]; };

package/{lib/constant/index.js → cjs/constant/constant.js}

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionStatus = exports.FlowStatus = exports.EVENT_INSTANCE_ERROR = exports.EVENT_INSTANCE_INTERRUPTED = exports.EVENT_INSTANCE_COMPLETE = exports.BASE_START_NODE = void 0;
 // baseType
 exports.BASE_START_NODE = 'start';
-// eventType
+// event name
 exports.EVENT_INSTANCE_COMPLETE = 'instance:complete';
 exports.EVENT_INSTANCE_INTERRUPTED = 'instance:interrupted';
 exports.EVENT_INSTANCE_ERROR = 'instance:error';
-// flowStatus
+// flow status
 var FlowStatus;
 (function (FlowStatus) {
     FlowStatus["COMPLETED"] = "completed";
@@ -16,11 +16,10 @@ var FlowStatus;
     FlowStatus["PENDING"] = "pending";
     FlowStatus["ERROR"] = "error";
 })(FlowStatus = exports.FlowStatus || (exports.FlowStatus = {}));
-// actionStatus
+// action status
 var ActionStatus;
 (function (ActionStatus) {
     ActionStatus["SUCCESS"] = "success";
     ActionStatus["ERROR"] = "error";
     ActionStatus["INTERRUPTED"] = "interrupted";
 })(ActionStatus = exports.ActionStatus || (exports.ActionStatus = {}));
-//# sourceMappingURL=index.js.map