@logicflow/engine 0.0.1

package/README.md

@@ -0,0 +1,22 @@
+# engine
+
+一个可以在JavaScript环境执行的流程引擎
+
+## 使用方式
+
+```js
+import LogicFlowEngine from '@logicflow/engine';
+
+const flowModel = new LogicFlowEngine({
+  graphData: {
+    nodes: [],
+    edges: [],
+  },
+  global: {
+    // 全局数据
+  }
+});
+
+flowModel.execute();
+
+```

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,252 @@
+"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.executeQueue = [];
+        // 执行中的任务
+        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.onTaskFinished(result);
+        });
+        this.scheduler.on(constant_1.EVENT_INSTANCE_INTERRUPTED, function (result) {
+            _this.onTaskFinished(result);
+        });
+    }
+    FlowModel.prototype.setStartNodeType = function (startNodeType) {
+        this.startNodeType = startNodeType;
+    };
+    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;
+        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,
+                });
+            }
+        });
+    };
+    /**
+     * 执行流程
+     * 同一次执行，这次执行内部的节点执行顺序为并行。
+     * 多次执行，多次执行之间为串行。
+     * 允许一个流程多次执行，效率更高。
+     * 例如：
+     * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
+     * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
+     * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
+     */
+    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();
+                return [2 /*return*/];
+            });
+        });
+    };
+    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();
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 创建节点实例
+     * @param nodeId 节点Id
+     * @returns 节点示例
+     */
+    FlowModel.prototype.createTask = function (nodeId) {
+        var nodeConfig = this.nodeConfigMap.get(nodeId);
+        var NodeModel = this.nodeModelMap.get(nodeConfig.type);
+        var task = new NodeModel({
+            nodeConfig: nodeConfig,
+            globalData: this.globalData,
+            context: this.context,
+        });
+        return task;
+    };
+    /**
+     * 更新流程全局数据
+     */
+    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.createExecution = function () {
+        var _this = this;
+        var execParams = this.executeQueue.shift();
+        this.executingInstance = execParams;
+        if (execParams.executionId) {
+            this.executionId = execParams.executionId;
+        }
+        else {
+            this.executionId = ID_1.createExecId();
+        }
+        // 如果有taskId，那么表示恢复执行
+        if (execParams.taskId) {
+            this.scheduler.resume({
+                executionId: this.executionId,
+                taskId: execParams.taskId,
+                nodeId: execParams.nodeId,
+                data: execParams.data,
+            });
+            return;
+        }
+        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.addTask({
+                executionId: _this.executionId,
+                nodeId: startNode.id,
+            });
+            // 所有的开始节点都执行
+        });
+        this.scheduler.run({
+            executionId: this.executionId,
+        });
+    };
+    return FlowModel;
+}());
+exports.default = FlowModel;

package/cjs/Scheduler.js

@@ -0,0 +1,278 @@
+"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.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 = ID_1.createTaskId();
+                var taskParam = __assign(__assign({}, currentNode), { taskId: taskId });
+                this.pushTaskToRunningMap(taskParam);
+                this.exec(taskParam);
+            }
+        }
+        else if (!this.hasRunningTask(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和taskRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+            this.emit(constant_1.EVENT_INSTANCE_COMPLETE, {
+                executionId: runParams.executionId,
+                nodeId: runParams.nodeId,
+                taskId: runParams.taskId,
+                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.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 === constant_1.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(constant_1.EVENT_INSTANCE_INTERRUPTED, {
+            executionId: taskParam.executionId,
+            status: constant_1.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_1.default));
+exports.default = Scheduler;

package/cjs/constant/LogCode.js

@@ -0,0 +1,31 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWarningMsg = exports.getErrorMsg = exports.WarningCode = exports.ErrorCode = void 0;
+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 = exports.ErrorCode || (exports.ErrorCode = {}));
+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 = exports.WarningCode || (exports.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);
+exports.getErrorMsg = function (code) { return "error[" + code + "]: " + errorMsgMapCn[code]; };
+exports.getWarningMsg = function (code) { return "warning[" + code + "]: " + warningMsgMapCn[code]; };

package/cjs/constant/constant.js

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