@logicflow/engine 0.0.10 → 0.0.11-beta.0

package/lib/EventEmitter.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = void 0;
-class EventEmitter {
-    constructor() {
-        this._events = {};
-    }
-    /**
-     * 添加一个监听事件
-     * @param evtKey 事件名称
-     * @param callback 回调方法
-     * @param once 是否触发一次
-     * @returns 当前 EventEmitter 实例
-     */
-    on(evtKey, callback, once) {
-        evtKey = evtKey.trim();
-        if (!this._events[evtKey]) {
-            this._events[evtKey] = [];
-        }
-        this._events[evtKey].push({
-            callback,
-            once: !!once,
-        });
-    }
-    /**
-     * 取消监听一个事件，或者一个 Channel
-     * @param evtKey
-     * @param callback
-     */
-    off(evtKey, callback) {
-        if (!evtKey) {
-            // evtKey 为空全部清除
-            this._events = {};
-        }
-        if (!callback) {
-            // evtKey 存在，callback 为空，清除事件所有方法
-            delete this._events[evtKey];
-        }
-        else {
-            // evtKey 存在，callback 存在，清除匹配的
-            const events = this._events[evtKey] || [];
-            let { length } = events;
-            for (let i = 0; i < length; i++) {
-                if (events[i].callback === callback) {
-                    events.splice(i, 1);
-                    length--;
-                    i--;
-                }
-            }
-            if (events.length === 0) {
-                delete this._events[evtKey];
-            }
-        }
-    }
-    /**
-     * 主动触发事件
-     * @param evtKey 触发事件名称
-     * @param eventArgs 事件参数
-     */
-    emit(evtKey, eventArgs) {
-        const events = this._events[evtKey] || [];
-        // 实际的处理 emit 方法
-        const doEmit = (es) => {
-            let { length } = es;
-            for (let i = 0; i < length; i++) {
-                if (!es[i]) {
-                    // eslint-disable-next-line no-continue
-                    continue;
-                }
-                const { callback, once } = es[i];
-                if (once) {
-                    es.splice(i, 1);
-                    if (es.length === 0) {
-                        delete this._events[evtKey];
-                    }
-                    length--;
-                    i--;
-                }
-                callback.apply(this, [eventArgs]);
-            }
-        };
-        doEmit(events);
-    }
-    /**
-     * 获取当前所有事件
-     * @returns _events
-     */
-    getEvents() {
-        return this._events;
-    }
-}
-exports.default = EventEmitter;
-exports.EventEmitter = EventEmitter;
-//# sourceMappingURL=EventEmitter.js.map

package/lib/EventEmitter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EventEmitter.js","sourceRoot":"","sources":["../src/EventEmitter.ts"],"names":[],"mappings":";;;AASA,MAAqB,YAAY;IAE/B;QACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAA;IACnB,CAAC;IAED;;;;;;OAMG;IACH,EAAE,CAAC,MAAc,EAAE,QAAsB,EAAE,IAAc;QACvD,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAA;QACtB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACzB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA;SAC1B;QACD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC;YACxB,QAAQ;YACR,IAAI,EAAE,CAAC,CAAC,IAAI;SACb,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,MAAc,EAAE,QAAuB;QACzC,IAAI,CAAC,MAAM,EAAE;YACX,gBAAgB;YAChB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAA;SAClB;QACD,IAAI,CAAC,QAAQ,EAAE;YACb,iCAAiC;YACjC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;SAC5B;aAAM;YACL,8BAA8B;YAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;YACzC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAA;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC/B,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,EAAE;oBACnC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;oBACnB,MAAM,EAAE,CAAA;oBACR,CAAC,EAAE,CAAA;iBACJ;aACF;YACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;gBACvB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;aAC5B;SACF;IACH,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,MAAc,EAAE,SAAoB;QACvC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;QACzC,gBAAgB;QAChB,MAAM,MAAM,GAAG,CAAC,EAAE,EAAE,EAAE;YACpB,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAA;YACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC/B,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;oBACV,uCAAuC;oBACvC,SAAQ;iBACT;gBACD,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;gBAChC,IAAI,IAAI,EAAE;oBACR,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;oBACf,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;wBACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;qBAC5B;oBACD,MAAM,EAAE,CAAA;oBACR,CAAC,EAAE,CAAA;iBACJ;gBACD,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,CAAA;aAClC;QACH,CAAC,CAAA;QACD,MAAM,CAAC,MAAM,CAAC,CAAA;IAChB,CAAC;IAED;;;OAGG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF;AA3FD,+BA2FC;AAEQ,oCAAY"}

package/lib/FlowModel.d.ts

@@ -1,146 +0,0 @@
-import { Engine } from '.';
-import { Recorder } from './recorder';
-import { Scheduler } from './Scheduler';
-import { BaseNode } from './nodes';
-export declare class FlowModel {
-    /**
-     * 流程支持的节点类型.
-     */
-    nodeModelMap: Map<string, BaseNode.NodeConstructor>;
-    /**
-     * 调度器，用于调度节点执行
-     */
-    scheduler: Scheduler;
-    /**
-     * 待执行的队列，当流程正在执行时，如果再次触发执行。那么会将执行参数放到队列中，等待上一次执行完成后再执行。
-     */
-    executeList: Partial<FlowModel.ExecParam>[];
-    /**
-     * 当前正在执行的任务。当监听到调度器执行完成时，触发执行参数中的回调，告知外部执行完成。
-     */
-    executingInstance?: FlowModel.ExecParam | null;
-    /**
-     * 当前流程模型中的所有节点，边会被转换成节点的 incoming 和 outgoing 属性
-     */
-    nodeConfigMap: Map<Engine.Key, BaseNode.NodeConfig>;
-    /**
-     * 当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
-     */
-    isRunning: boolean;
-    /**
-     * 开始接地那类型，在执行流程时，会从这些节点开始执行
-     */
-    startNodeType: string;
-    /**
-     * 当前流程中开始节点组成的数组
-     */
-    startNodes: BaseNode.NodeConfig[];
-    /**
-     * 用于存储全局数据，最终会传递给每个节点
-     */
-    globalData: Record<string, unknown>;
-    /**
-     * 外部传入的上下文，最终会传递给每个节点
-     * 例如：
-     * const context = {
-     *   request: {
-     *     get: (url) => {
-     *       return fetch(url);
-     *     },
-     *   },
-     * }
-     * 在节点内可以通过 this.context.request.get(url) 来调用。
-     */
-    context: Record<string, unknown>;
-    constructor({ nodeModelMap, recorder, context, globalData, startNodeType, }: FlowModel.IFlowModelProps);
-    /**
-     * 解析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 流程图数据
-     */
-    load(graphData: Engine.GraphConfigData): void;
-    /**
-     * 从待执行队列中取出需要执行的内容。
-     * 会依次判断是否有 actionId、nodeId、executionId。
-     * 若存在 actionId，那么表示恢复执行
-     * 若存在 nodeId，那么表示从指定节点开始执行
-     * 若都不存在，那么新建一个 executionId，从开始节点开始执行
-     * @private
-     */
-    private createExecution;
-    /**
-     * 执行流程，每次执行都会生成一个唯一的 executionId，用于区分不同的执行。
-     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行
-     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
-     * 例如：
-     * 一个流程存在两个开始节点，A 和 B，A 和 B 的下一个节点都是 C，C 的下两个节点是 D 和 E
-     * 外部分别触发了 A 和 B 的执行，那么 A 和 B 的执行是串行（即 A 执行完再执行 B），但是 D 和 E 的执行是并行的。
-     * 如果希望 A 和 B 的执行时并行的，就不能使用同一个流程模型执行，应该初始化两个。
-     * 下面直接使用调度器的队列
-     * @param params
-     */
-    execute(params: Partial<FlowModel.ExecParam>): Promise<void>;
-    resume(params: Partial<FlowModel.ExecParam>): Promise<void>;
-    /**
-     * 创建节点实例，每个节点实例都会有一个唯一的 actionId
-     * 通过 executionId, nodeId, actionId 可以唯一确定一个节点的某一次执行
-     * @param nodeId
-     * @returns 节点实例
-     */
-    createAction(nodeId: Engine.Key): BaseNode | undefined;
-    setStartNodeType(type: string): void;
-    updateGlobalData(data: Record<string, unknown>): Record<string, unknown>;
-    /**
-     * 在执行完成后，通知外部此次之行完成
-     * 如果还存在待执行的任务，那么继续执行
-     * @param result
-     * @private
-     */
-    private onExecuteFinished;
-}
-export declare namespace FlowModel {
-    type FlowResult = ({
-        result?: Record<string, unknown>;
-    } & Engine.ActionParam) | Engine.NextActionParam;
-    type ActionParam = Scheduler.ActionParam;
-    type ExecParam = {
-        callback?: (result: Engine.NextActionParam) => void;
-        onError?: (error: Error) => void;
-    } & ActionParam;
-    interface IFlowModelProps {
-        nodeModelMap: Map<string, BaseNode.NodeConstructor>;
-        recorder?: Recorder;
-        context?: Record<string, unknown>;
-        globalData?: Record<string, unknown>;
-        startNodeType?: string;
-    }
-}
-export default FlowModel;

package/lib/FlowModel.js

@@ -1,236 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowModel = void 0;
-const tslib_1 = require("tslib");
-const Scheduler_1 = require("./Scheduler");
-const utils_1 = require("./utils");
-const constant_1 = require("./constant");
-const logCode_1 = require("./constant/logCode");
-class FlowModel {
-    constructor({ nodeModelMap, recorder, context = {}, globalData = {}, startNodeType = 'StartNode', }) {
-        /**
-         * 当前流程模型中的所有节点，边会被转换成节点的 incoming 和 outgoing 属性
-         */
-        this.nodeConfigMap = new Map();
-        /**
-         * 当前流程中开始节点组成的数组
-         */
-        this.startNodes = [];
-        /**
-         * 用于存储全局数据，最终会传递给每个节点
-         */
-        this.globalData = {};
-        // 流程包含的节点类型 ??? 在 load 代码中又初始化了一遍，为什么要传进来
-        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.Scheduler({
-            flowModel: this,
-            recorder,
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_COMPLETE, (result) => {
-            this.onExecuteFinished(result);
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_INTERRUPTED, (result) => {
-            this.onExecuteFinished(result);
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_ERROR, (result) => {
-            this.onExecuteFinished(result);
-        });
-    }
-    /**
-     * 解析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 流程图数据
-     */
-    load(graphData) {
-        const { nodes = [], edges = [] } = graphData;
-        nodes.forEach((node) => {
-            if (this.nodeModelMap.has(node.type)) {
-                const 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(`未识别的节点类型：${node.type}`);
-            }
-        });
-        edges.forEach((edge) => {
-            const sourceNode = this.nodeConfigMap.get(edge.sourceNodeId);
-            const 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,
-                });
-            }
-        });
-    }
-    /**
-     * 从待执行队列中取出需要执行的内容。
-     * 会依次判断是否有 actionId、nodeId、executionId。
-     * 若存在 actionId，那么表示恢复执行
-     * 若存在 nodeId，那么表示从指定节点开始执行
-     * 若都不存在，那么新建一个 executionId，从开始节点开始执行
-     * @private
-     */
-    createExecution(execParam) {
-        var _a;
-        this.executeList.push(execParam);
-        // 如果有 actionId，则表示恢复执行
-        // TODO: 待测试，确认该流程
-        if (execParam.actionId && execParam.nodeId && execParam.executionId) {
-            this.scheduler.resume({
-                executionId: execParam.executionId,
-                actionId: execParam.actionId,
-                nodeId: execParam.nodeId,
-                data: execParam.data,
-            });
-            return;
-        }
-        // 否则，判断 executionId 是否存在，使用 executionId 或创建新的 execution，从开始节点开始执行
-        // const executionId = execParam?.executionId || createExecId()
-        const executionId = (0, utils_1.createExecId)();
-        execParam.executionId = executionId;
-        // 当指定了具体需要执行的节点时，执行下面方法
-        if (execParam === null || execParam === void 0 ? void 0 : execParam.nodeId) {
-            const nodeConfig = this.nodeConfigMap.get(execParam.nodeId);
-            if (!nodeConfig) {
-                (_a = execParam === null || execParam === void 0 ? void 0 : execParam.onError) === null || _a === void 0 ? void 0 : _a.call(execParam, new Error(`${(0, logCode_1.getErrorMsg)(logCode_1.ErrorCode.NONE_NODE_ID)}(${execParam.nodeId})`));
-                return;
-            }
-            // 当指定了开始节点，且该节点存在，则直接以这个节点开始执行
-            this.startNodes = [nodeConfig];
-        }
-        this.startNodes.forEach((startNode) => {
-            this.scheduler.addAction({
-                executionId,
-                nodeId: startNode.id,
-            });
-        });
-        // 所有的开始节点都执行
-        this.scheduler.run({
-            executionId,
-        });
-    }
-    /**
-     * 执行流程，每次执行都会生成一个唯一的 executionId，用于区分不同的执行。
-     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行
-     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
-     * 例如：
-     * 一个流程存在两个开始节点，A 和 B，A 和 B 的下一个节点都是 C，C 的下两个节点是 D 和 E
-     * 外部分别触发了 A 和 B 的执行，那么 A 和 B 的执行是串行（即 A 执行完再执行 B），但是 D 和 E 的执行是并行的。
-     * 如果希望 A 和 B 的执行时并行的，就不能使用同一个流程模型执行，应该初始化两个。
-     * 下面直接使用调度器的队列
-     * @param params
-     */
-    execute(params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.createExecution(params);
-        });
-    }
-    resume(params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.createExecution(params);
-        });
-    }
-    /**
-     * 创建节点实例，每个节点实例都会有一个唯一的 actionId
-     * 通过 executionId, nodeId, actionId 可以唯一确定一个节点的某一次执行
-     * @param nodeId
-     * @returns 节点实例
-     */
-    // TODO: 确认下面这种场景，类型如何定义
-    createAction(nodeId) {
-        const nodeConfig = this.nodeConfigMap.get(nodeId);
-        if (nodeConfig) {
-            const NodeModel = this.nodeModelMap.get(nodeConfig.type);
-            if (!NodeModel) {
-                throw new Error('该 NodeModel 不存在，抛出异常');
-            }
-            return new NodeModel({
-                nodeConfig,
-                globalData: this.globalData,
-                context: this.context,
-            });
-        }
-    }
-    setStartNodeType(type) {
-        this.startNodeType = type;
-    }
-    updateGlobalData(data) {
-        // TODO: 数据的合并，是否考虑子项的合并（默认值的替换）
-        this.globalData = Object.assign(Object.assign({}, this.globalData), data);
-        return this.globalData;
-    }
-    /**
-     * 在执行完成后，通知外部此次之行完成
-     * 如果还存在待执行的任务，那么继续执行
-     * @param result
-     * @private
-     */
-    onExecuteFinished(result) {
-        const index = this.executeList.findIndex((i) => i.executionId === result.executionId);
-        if (index > -1) {
-            const { callback } = this.executeList[index];
-            this.executeList.splice(index, 1);
-            callback === null || callback === void 0 ? void 0 : callback(result);
-        }
-    }
-}
-exports.FlowModel = FlowModel;
-exports.default = FlowModel;
-//# sourceMappingURL=FlowModel.js.map

package/lib/FlowModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FlowModel.js","sourceRoot":"","sources":["../src/FlowModel.ts"],"names":[],"mappings":"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"}

package/lib/Scheduler.d.ts

@@ -1,78 +0,0 @@
-import { Engine } from '.';
-import Recorder from './recorder';
-import FlowModel from './FlowModel';
-import EventEmitter from './EventEmitter';
-/**
- * 调度器
- * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
- */
-export declare class Scheduler extends EventEmitter {
-    /**
-     * 当前需要执行的节点队列
-     */
-    nodeQueueMap: Map<Engine.Key, Engine.NodeParam[]>;
-    /**
-     * 当前正在执行的节点集合
-     * 在每个节点执行完成后，会从集合中删除
-     * 同时会判断次集合中是否还存在和此节点相同的 executionId，如果不存在，说明该流程已经执行完成
-     */
-    actionRunningMap: Map<Engine.Key, Scheduler.ActionParamMap>;
-    /**
-     * 流程模型，用于创建节点模型
-     */
-    flowModel: FlowModel;
-    /**
-     * 执行记录存储器
-     * 用于存储节点执行的结果
-     */
-    recorder?: Recorder;
-    constructor(config: Scheduler.ISchedulerProps);
-    /**
-     * 添加一个任务到队列中。
-     * 1. 由流程模型将所有的开始及诶带你添加到队列中
-     * 2. 当一个节点执行完成后，将后续的节点添加到队列中
-     * @param nodeParam
-     */
-    addAction(nodeParam: Engine.NodeParam): void;
-    private pushActionToRunningMap;
-    private removeActionFromRunningMap;
-    /**
-     * 为了防止多次添加导致
-     * @param actionParam
-     */
-    private saveActionResult;
-    private hasRunningAction;
-    /**
-     * 调度器执行下一个任务
-     * 1. 提供给流程模型，用户开始执行第一个任务
-     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务
-     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件
-     * @param runParam
-     */
-    run(runParam: Scheduler.ActionParam): void;
-    private next;
-    /**
-     * 恢复某个任务的执行
-     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行
-     * @param resumeParam
-     */
-    resume(resumeParam: Engine.ResumeParam): Promise<void>;
-    private interrupted;
-    private error;
-    private exec;
-}
-export declare namespace Scheduler {
-    type ActionParam = {
-        executionId: Engine.Key;
-        actionId?: Engine.Key;
-        nodeId?: Engine.Key;
-        data?: Record<string, unknown>;
-        [key: string]: unknown;
-    };
-    type ActionParamMap = Map<Engine.Key, ActionParam>;
-    interface ISchedulerProps {
-        flowModel: FlowModel;
-        recorder?: Recorder;
-    }
-}
-export default Scheduler;