@logicflow/engine 0.0.1

package/cjs/recorder/index.js

@@ -0,0 +1,112 @@
+"use strict";
+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 storage_1 = require("../util/storage");
+var LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES';
+var Recorder = /** @class */ (function () {
+    function Recorder() {
+    }
+    /*
+    * @param {Object} task
+    * {
+    *   taskId: '',
+    *   nodeId: '',
+    *   executionId: '',
+    *   nodeType: '',
+    *   timestamp: '',
+    *   properties: {},
+    * }
+    */
+    Recorder.prototype.addTask = function (task) {
+        return __awaiter(this, void 0, void 0, function () {
+            var executionId, taskId, instanceData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        executionId = task.executionId, taskId = task.taskId;
+                        return [4 /*yield*/, this.getExecutionTasks(executionId)];
+                    case 1:
+                        instanceData = _a.sent();
+                        if (!instanceData) {
+                            this.pushExecution(executionId);
+                        }
+                        this.pushTaskToExecution(executionId, taskId);
+                        storage_1.default.setItem(taskId, task);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Recorder.prototype.getTask = function (taskId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, storage_1.default.getItem(taskId)];
+            });
+        });
+    };
+    Recorder.prototype.getExecutionTasks = function (executionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, storage_1.default.getItem(executionId)];
+            });
+        });
+    };
+    Recorder.prototype.clear = function () {
+        var instance = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        instance.forEach(function (executionId) {
+            storage_1.default.removeItem(executionId);
+            var instanceData = storage_1.default.getItem(executionId) || [];
+            instanceData.forEach(function (taskId) {
+                storage_1.default.removeItem(taskId);
+            });
+        });
+        storage_1.default.removeItem(LOGICFLOW_ENGINE_INSTANCES);
+    };
+    Recorder.prototype.pushExecution = function (executionId) {
+        var instance = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        instance.push(executionId);
+        storage_1.default.setItem(LOGICFLOW_ENGINE_INSTANCES, instance);
+    };
+    Recorder.prototype.pushTaskToExecution = function (executionId, taskId) {
+        var tasks = storage_1.default.getItem(executionId) || [];
+        tasks.push(taskId);
+        storage_1.default.setItem(executionId, tasks);
+    };
+    return Recorder;
+}());
+exports.default = Recorder;

package/cjs/util/ID.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskId = exports.createExecId = void 0;
+var uuid_1 = require("uuid");
+exports.createExecId = function () {
+    var uuid = uuid_1.v4();
+    return "exec-" + uuid;
+};
+exports.createTaskId = function () {
+    var uuid = uuid_1.v4();
+    return "task-" + uuid;
+};

package/cjs/util/global.js

@@ -0,0 +1,32 @@
+"use strict";
+// The one and only way of getting global scope in all environments
+// https://stackoverflow.com/q/3277182/1008999
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInNodeJS = exports.isInWebWorker = exports.isInBrowser = exports.globalScope = void 0;
+var isInBrowser = typeof window === 'object' && window.window === window;
+exports.isInBrowser = isInBrowser;
+var isInNodeJS = typeof global === 'object' && global.global === global;
+exports.isInNodeJS = isInNodeJS;
+// eslint-disable-next-line no-restricted-globals
+var isInWebWorker = !isInBrowser && typeof self === 'object' && self.constructor;
+exports.isInWebWorker = isInWebWorker;
+var globalScope = (function () {
+    if (isInBrowser) {
+        return window;
+    }
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof self === 'object' && self.self === self) { // web workers
+        // eslint-disable-next-line no-restricted-globals
+        return self;
+    }
+    if (isInNodeJS) {
+        return global;
+    }
+    if (typeof globalThis === 'object') {
+        return globalThis;
+    }
+    return {
+        eval: function () { return undefined; },
+    };
+})();
+exports.globalScope = globalScope;

package/cjs/util/storage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 存储执行记录
+ */
+var global_1 = require("./global");
+if (!global_1.globalScope.sessionStorage) {
+    var storage_1 = {
+        data: {},
+        setItem: function (key, value) {
+            storage_1.data[key] = value;
+        },
+        getItem: function (key) {
+            return storage_1.data[key];
+        },
+        removeItem: function (key) {
+            delete storage_1.data[key];
+        },
+    };
+    global_1.globalScope.sessionStorage = storage_1;
+}
+exports.default = {
+    setItem: function (key, value) {
+        if (typeof value === 'object') {
+            value = JSON.stringify(value);
+        }
+        global_1.globalScope.sessionStorage.setItem(key, value);
+    },
+    getItem: function (key) {
+        var value = global_1.globalScope.sessionStorage.getItem(key);
+        try {
+            return JSON.parse(value);
+        }
+        catch (e) {
+            return value;
+        }
+    },
+    removeItem: function (key) {
+        global_1.globalScope.sessionStorage.removeItem(key);
+    },
+};

package/es/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+export default class EventEmitter {
+    _events: Record<string, any>;
+    constructor();
+    on(evKey: any, callback: any, once?: boolean): void;
+    emit(evt: any, eventArgs: any): void;
+    off(evt: any, callback: any): void;
+}

package/es/EventEmitter.js

@@ -0,0 +1,68 @@
+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;
+}());
+export default EventEmitter;

package/es/FlowModel.d.ts

@@ -0,0 +1,104 @@
+import type { NodeConfig, NodeConstructor } from './nodes/BaseNode';
+import type Recorder from './recorder';
+import Scheduler from './Scheduler';
+import type { TaskParam } from './types.d';
+export declare type FlowResult = {
+    result?: Record<string, any>;
+} & TaskParam;
+export declare type TaskParams = {
+    executionId?: string;
+    taskId?: string;
+    nodeId?: string;
+    data?: Record<string, any>;
+};
+export declare type ExecParams = {
+    callback?: (result: FlowResult) => void;
+    onError?: (error: Error) => void;
+} & TaskParams;
+export default class FlowModel {
+    /**
+     * 流程支持的节点类型
+     */
+    nodeModelMap: Map<string, NodeConstructor>;
+    /**
+     * 每一次执行流程都会生成一个唯一的executionId。
+     */
+    executionId: string;
+    /**
+     * 调度器，用于调度节点的执行。
+     */
+    scheduler: Scheduler;
+    /**
+     * 待执行的队列，当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
+     */
+    executeQueue: ExecParams[];
+    /**
+     * 当前正在执行。当监听到调度器执行完成时，出触发执行参数中的回调，告知外部执行完成。
+     */
+    executingInstance: ExecParams;
+    /**
+     * 当前流程模型中的所有节点，边会被转换成节点的incoming和outgoing属性。
+     */
+    nodeConfigMap: Map<string, NodeConfig>;
+    /**
+     * 当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
+     */
+    isRunning: boolean;
+    /**
+     * 开始节点类型，在执行流程时，会从这些节点开始执行。
+     */
+    startNodeType: string;
+    /**
+     * 当前流程中开始节点组成的数组。
+     */
+    startNodes: NodeConfig[];
+    /**
+     * 用于存储全局数据，可以在流程中共享。
+     */
+    globalData: Record<string, any>;
+    /**
+     * 外部传入的上下文，最终会传递给每个节点
+     * 例如：
+     * const context = {
+     *  request: {
+     *   get: (url) => {
+     *    return fetch(url);
+     *  }
+     * }
+     * 在节点内部可以通过 this.context.request.get(url) 来调用。
+     */
+    context: Record<string, any>;
+    constructor({ nodeModelMap, recorder, context, globalData, startNodeType, }: {
+        nodeModelMap: Map<string, NodeConstructor>;
+        recorder: Recorder;
+        context?: Record<string, any>;
+        globalData?: Record<string, any>;
+        startNodeType?: string;
+    });
+    setStartNodeType(startNodeType: any): void;
+    load(graphData: any): void;
+    /**
+     * 执行流程
+     * 同一次执行，这次执行内部的节点执行顺序为并行。
+     * 多次执行，多次执行之间为串行。
+     * 允许一个流程多次执行，效率更高。
+     * 例如：
+     * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
+     * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
+     * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
+     */
+    execute(params: ExecParams): Promise<void>;
+    resume(params: ExecParams): Promise<void>;
+    /**
+     * 创建节点实例
+     * @param nodeId 节点Id
+     * @returns 节点示例
+     */
+    createTask(nodeId: string): import("./nodes/BaseNode").default;
+    /**
+     * 更新流程全局数据
+     */
+    updateGlobalData(data: any): void;
+    private onTaskFinished;
+    private createExecution;
+}

package/es/FlowModel.js

@@ -0,0 +1,250 @@
+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 { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, } from './constant/constant';
+import { createExecId } from './util/ID';
+import Scheduler from './Scheduler';
+import { ErrorCode, getErrorMsg } from './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({
+            flowModel: this,
+            recorder: recorder,
+        });
+        this.scheduler.on(EVENT_INSTANCE_COMPLETE, function (result) {
+            _this.onTaskFinished(result);
+        });
+        this.scheduler.on(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 = 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(getErrorMsg(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;
+}());
+export default FlowModel;

package/es/Scheduler.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from './EventEmitter';
+import type { TaskParam, NodeParam, ResumeParam } from './types.d';
+import type FlowModel from './FlowModel';
+import type Recorder from './recorder';
+declare type TaskParamMap = Map<string, TaskParam>;
+/**
+ * 调度器
+ * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
+ */
+export default class Scheduler extends EventEmitter {
+    nodeQueueMap: Map<string, NodeParam[]>;
+    taskRunningMap: Map<string, TaskParamMap>;
+    flowModel: FlowModel;
+    recorder: Recorder;
+    currentTask: TaskParam | null;
+    constructor(config: any);
+    /**
+     * 添加一个任务到队列中。
+     * 1. 由流程模型将所有的开始节点添加到队列中。
+     * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
+     */
+    addTask(nodeParam: NodeParam): void;
+    /**
+     * 调度器执行下一个任务
+     * 1. 提供给流程模型，用户开始执行第一个任务。
+     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务。
+     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件。
+     */
+    run(runParams: {
+        executionId: string;
+        nodeId?: string;
+        taskId?: string;
+    }): void;
+    /**
+     * 恢复某个任务的执行。
+     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
+     */
+    resume(resumeParam: ResumeParam): Promise<void>;
+    stop(data: any): void;
+    private pushTaskToRunningMap;
+    private removeTaskFromRunningMap;
+    private hasRunningTask;
+    private exec;
+    private interrupted;
+    private next;
+    /**
+     * 为了防止多次添加导致
+     */
+    private saveTaskResult;
+}
+export {};