@logicflow/engine 0.0.10 → 0.0.11-beta.0

package/cjs/recorder/index.js

@@ -0,0 +1,168 @@
+"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 MAX_RECORDER = 100;
+var MAX_INSTANCE = 100;
+var Recorder = /** @class */ (function () {
+    function Recorder(_a) {
+        var instanceId = _a.instanceId;
+        this.maxRecorder = MAX_RECORDER;
+        this.instanceId = instanceId;
+        var instances = this.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        if (instances.indexOf(instanceId) === -1) {
+            instances.push(instanceId);
+        }
+        if (instances.length > MAX_INSTANCE) {
+            var clearInstance = instances.shift();
+            this.clearInstance(clearInstance);
+        }
+        this.setItem(LOGICFLOW_ENGINE_INSTANCES, instances);
+    }
+    Recorder.prototype.setMaxRecorderNumber = function (maxRecorder) {
+        this.maxRecorder = maxRecorder;
+    };
+    // 将存储 storage 的方法收敛到此处，并在此处做异常处理 - setItem
+    Recorder.prototype.setItem = function (key, value) {
+        try {
+            storage_1.default.setItem(key, value);
+        }
+        catch (error) {
+            console.log('Ops, something wrong with storage.setItem');
+            storage_1.default.clear();
+            storage_1.default.setItem(key, value);
+        }
+    };
+    // getItem 方法
+    Recorder.prototype.getItem = function (key) {
+        return storage_1.default.getItem(key);
+    };
+    /*
+    * @param {Object} action
+    * {
+    *   actionId: '',
+    *   nodeId: '',
+    *   executionId: '',
+    *   nodeType: '',
+    *   timestamp: '',
+    *   properties: {},
+    * }
+    */
+    Recorder.prototype.addActionRecord = function (action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var executionId, actionId, instanceData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        executionId = action.executionId, actionId = action.actionId;
+                        return [4 /*yield*/, this.getExecutionActions(executionId)];
+                    case 1:
+                        instanceData = _a.sent();
+                        if (!instanceData) {
+                            this.pushExecution(executionId);
+                        }
+                        this.pushActionToExecution(executionId, actionId);
+                        this.setItem(actionId, action);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Recorder.prototype.getActionRecord = function (actionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getItem(actionId)];
+            });
+        });
+    };
+    Recorder.prototype.getExecutionActions = function (executionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getItem(executionId)];
+            });
+        });
+    };
+    Recorder.prototype.getExecutionList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var instances;
+            return __generator(this, function (_a) {
+                instances = this.getItem(this.instanceId) || [];
+                return [2 /*return*/, instances];
+            });
+        });
+    };
+    Recorder.prototype.clear = function () {
+        this.clearInstance(this.instanceId);
+    };
+    Recorder.prototype.clearInstance = function (instanceId) {
+        var _this = this;
+        var instanceExecutions = this.getItem(instanceId) || [];
+        instanceExecutions.forEach(function (executionId) {
+            storage_1.default.removeItem(executionId);
+            var instanceData = _this.getItem(executionId) || [];
+            instanceData.forEach(function (actionId) {
+                storage_1.default.removeItem(actionId);
+            });
+        });
+        storage_1.default.removeItem(instanceId);
+    };
+    Recorder.prototype.pushExecution = function (executionId) {
+        var instanceExecutions = this.getItem(this.instanceId) || [];
+        if (instanceExecutions.length >= this.maxRecorder) {
+            var removeItem = instanceExecutions.shift();
+            this.popExecution(removeItem);
+        }
+        instanceExecutions.push(executionId);
+        this.setItem(this.instanceId, instanceExecutions);
+    };
+    Recorder.prototype.popExecution = function (executionId) {
+        var instanceData = this.getItem(executionId) || [];
+        instanceData.forEach(function (actionId) {
+            storage_1.default.removeItem(actionId);
+        });
+        storage_1.default.removeItem(executionId);
+    };
+    Recorder.prototype.pushActionToExecution = function (executionId, actionId) {
+        var actions = this.getItem(executionId) || [];
+        actions.push(actionId);
+        this.setItem(executionId, actions);
+    };
+    return Recorder;
+}());
+exports.default = Recorder;

package/cjs/util/ID.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEngineId = exports.createActionId = exports.createExecId = void 0;
+var uuid_1 = require("uuid");
+exports.createExecId = function () {
+    var uuid = uuid_1.v4();
+    return "exec-" + uuid;
+};
+exports.createActionId = function () {
+    var uuid = uuid_1.v4();
+    return "action-" + uuid;
+};
+exports.createEngineId = function () {
+    var uuid = uuid_1.v4();
+    return "engine-" + 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/{lib/utils → cjs/util}/storage.js

@@ -3,46 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * 存储执行记录
  */
-const global_1 = require("./global");
+var global_1 = require("./global");
 if (!global_1.globalScope.sessionStorage) {
-    const storage = {
+    var storage_1 = {
         data: {},
-        setItem(key, value) {
-            storage.data[key] = value;
+        setItem: function (key, value) {
+            storage_1.data[key] = value;
         },
-        getItem(key) {
-            return storage.data[key];
+        getItem: function (key) {
+            return storage_1.data[key];
         },
-        removeItem(key) {
-            delete storage.data[key];
+        removeItem: function (key) {
+            delete storage_1.data[key];
         },
-        clear() {
-            storage.data = {};
+        clear: function () {
+            storage_1.data = {};
         },
     };
-    global_1.globalScope.sessionStorage = storage;
+    global_1.globalScope.sessionStorage = storage_1;
 }
 exports.default = {
-    setItem(key, value) {
+    setItem: function (key, value) {
         if (typeof value === 'object') {
             value = JSON.stringify(value);
         }
         global_1.globalScope.sessionStorage.setItem(key, value);
     },
-    getItem(key) {
-        const value = global_1.globalScope.sessionStorage.getItem(key);
+    getItem: function (key) {
+        var value = global_1.globalScope.sessionStorage.getItem(key);
         try {
             return JSON.parse(value);
         }
-        catch (error) {
+        catch (e) {
             return value;
         }
     },
-    removeItem(key) {
+    removeItem: function (key) {
         global_1.globalScope.sessionStorage.removeItem(key);
     },
-    clear() {
+    clear: function () {
         global_1.globalScope.sessionStorage.clear();
     },
 };
-//# sourceMappingURL=storage.js.map

package/es/EventEmitter.d.ts

@@ -1,37 +1,7 @@
-export interface EventType {
-    readonly callback: (params?: any) => void;
-    readonly once: boolean;
-}
-export type EventArgs = Record<string, unknown>;
-export type EventsType = Record<string, EventType[]>;
-export type CallbackType = (...args: unknown[]) => void;
 export default class EventEmitter {
-    private _events;
+    _events: Record<string, any>;
     constructor();
-    /**
-     * 添加一个监听事件
-     * @param evtKey 事件名称
-     * @param callback 回调方法
-     * @param once 是否触发一次
-     * @returns 当前 EventEmitter 实例
-     */
-    on(evtKey: string, callback: CallbackType, once?: boolean): void;
-    /**
-     * 取消监听一个事件，或者一个 Channel
-     * @param evtKey
-     * @param callback
-     */
-    off(evtKey: string, callback?: CallbackType): void;
-    /**
-     * 主动触发事件
-     * @param evtKey 触发事件名称
-     * @param eventArgs 事件参数
-     */
-    emit(evtKey: string, eventArgs: EventArgs): void;
-    /**
-     * 获取当前所有事件
-     * @returns _events
-     */
-    getEvents(): EventsType;
+    on(evKey: any, callback: any, once?: boolean): void;
+    emit(evt: any, eventArgs: any): void;
+    off(evt: any, callback: any): void;
 }
-export { EventEmitter };

package/es/EventEmitter.js

@@ -1,90 +1,68 @@
-export default class EventEmitter {
-    constructor() {
+var EventEmitter = /** @class */ (function () {
+    function EventEmitter() {
         this._events = {};
     }
-    /**
-     * 添加一个监听事件
-     * @param evtKey 事件名称
-     * @param callback 回调方法
-     * @param once 是否触发一次
-     * @returns 当前 EventEmitter 实例
-     */
-    on(evtKey, callback, once) {
-        evtKey = evtKey.trim();
-        if (!this._events[evtKey]) {
-            this._events[evtKey] = [];
+    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[evtKey].push({
-            callback,
+        this._events[evKey].push({
+            callback: 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] || [];
+    };
+    EventEmitter.prototype.emit = function (evt, eventArgs) {
+        var _this = this;
+        var events = this._events[evt] || [];
         // 实际的处理 emit 方法
-        const doEmit = (es) => {
-            let { length } = es;
-            for (let i = 0; i < length; i++) {
+        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;
                 }
-                const { callback, once } = es[i];
+                var _a = es[i], callback = _a.callback, once = _a.once;
                 if (once) {
                     es.splice(i, 1);
                     if (es.length === 0) {
-                        delete this._events[evtKey];
+                        delete _this._events[evt];
                     }
                     length--;
                     i--;
                 }
-                callback.apply(this, [eventArgs]);
+                callback.apply(_this, [eventArgs]);
             }
         };
         doEmit(events);
-    }
-    /**
-     * 获取当前所有事件
-     * @returns _events
-     */
-    getEvents() {
-        return this._events;
-    }
-}
-export { EventEmitter };
-//# sourceMappingURL=EventEmitter.js.map
+    };
+    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

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