@logicflow/engine 0.0.8 → 0.0.10-beta.0

package/lib/utils/id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.js","sourceRoot":"","sources":["../../src/utils/id.ts"],"names":[],"mappings":";;;AAAA,+BAAmC;AAE5B,MAAM,YAAY,GAAG,GAAW,EAAE;IACvC,MAAM,IAAI,GAAG,IAAA,SAAM,GAAE,CAAA;IACrB,OAAO,QAAQ,IAAI,EAAE,CAAA;AACvB,CAAC,CAAA;AAHY,QAAA,YAAY,gBAGxB;AAEM,MAAM,cAAc,GAAG,GAAW,EAAE;IACzC,MAAM,IAAI,GAAG,IAAA,SAAM,GAAE,CAAA;IACrB,OAAO,UAAU,IAAI,EAAE,CAAA;AACzB,CAAC,CAAA;AAHY,QAAA,cAAc,kBAG1B;AAEM,MAAM,cAAc,GAAG,GAAW,EAAE;IACzC,MAAM,IAAI,GAAG,IAAA,SAAM,GAAE,CAAA;IACrB,OAAO,UAAU,IAAI,EAAE,CAAA;AACzB,CAAC,CAAA;AAHY,QAAA,cAAc,kBAG1B"}

package/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+import storage from './storage';
+export * from './global';
+export * from './id';
+export { storage };

package/lib/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const tslib_1 = require("tslib");
+const storage_1 = tslib_1.__importDefault(require("./storage"));
+exports.storage = storage_1.default;
+tslib_1.__exportStar(require("./global"), exports);
+tslib_1.__exportStar(require("./id"), exports);
+//# sourceMappingURL=index.js.map

package/lib/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;AAAA,gEAA+B;AAItB,kBAJF,iBAAO,CAIE;AAFhB,mDAAwB;AACxB,+CAAoB"}

package/lib/utils/storage.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    setItem(key: any, value: any): void;
+    getItem(key: any): any;
+    removeItem(key: any): void;
+    clear(): void;
+};
+export default _default;

package/{cjs/util → lib/utils}/storage.js

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

package/lib/utils/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/utils/storage.ts"],"names":[],"mappings":";;AAAA;;GAEG;AACH,qCAAsC;AAEtC,IAAI,CAAC,oBAAW,CAAC,cAAc,EAAE;IAC/B,MAAM,OAAO,GAAG;QACd,IAAI,EAAE,EAA6B;QAEnC,OAAO,CAAC,GAAG,EAAE,KAAK;YAChB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;QAC3B,CAAC;QAED,OAAO,CAAC,GAAG;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAC1B,CAAC;QAED,UAAU,CAAC,GAAG;YACZ,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAC1B,CAAC;QAED,KAAK;YACH,OAAO,CAAC,IAAI,GAAG,EAAE,CAAA;QACnB,CAAC;KACF,CAAA;IAED,oBAAW,CAAC,cAAc,GAAG,OAAO,CAAA;CACrC;AAED,kBAAe;IACb,OAAO,CAAC,GAAG,EAAE,KAAK;QAChB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;SAC9B;QAED,oBAAW,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAChD,CAAC;IAED,OAAO,CAAC,GAAG;QACT,MAAM,KAAK,GAAG,oBAAW,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACrD,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;SACzB;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,KAAK,CAAA;SACb;IACH,CAAC;IAED,UAAU,CAAC,GAAG;QACZ,oBAAW,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;IAC5C,CAAC;IAED,KAAK;QACH,oBAAW,CAAC,cAAc,CAAC,KAAK,EAAE,CAAA;IACpC,CAAC;CACF,CAAA"}

package/package.json

@@ -1,90 +1,49 @@
 {
   "name": "@logicflow/engine",
-  "version": "0.0.8",
+  "version": "0.0.10-beta.0",
   "description": "a process engine for javascript",
-  "main": "cjs/index.js",
+  "main": "lib/index.js",
   "module": "es/index.js",
-  "homepage": "https://docs.logic-flow.cn",
   "types": "es/index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/didi/LogicFlow",
-    "directory": "packages/engine"
-  },
   "browser": {
-    "vm": "./es/expression/browserVm.js"
-  },
-  "license": "Apache-2.0",
-  "scripts": {
-    "dev": "cross-env NODE_ENV=development webpack-dev-server --client-log-level warning --config scripts/webpack.config.dev.js",
-    "types": "tsc -d --declarationDir ./types --outDir temp && rimraf -R temp",
-    "build:esm": "tsc --module esnext --target es5 --outDir ./es -d",
-    "build:cjs": "tsc --module commonjs --target es5 --outDir ./cjs",
-    "build:umd": "cross-env NODE_ENV=production webpack --config scripts/webpack.config.build.js",
-    "build": "rimraf ./es ./cjs ./lib && npm run build:esm & npm run build:cjs & npm run build:umd",
-    "publish-lib": "npm run build && npm publish",
-    "test": "jest",
-    "test:watch": "jest --watch"
+    "./es/platform/node/index.js": "./es/platform/browser/index.js"
   },
-  "author": "",
+  "jsdeliver": "dist/index.js",
+  "unpkg": "dist/index.js",
   "files": [
-    "cjs",
+    "dist",
     "es",
     "lib",
-    "types",
+    "src",
     "readme.md"
   ],
-  "dependencies": {
-    "uuid": "^8.2.0"
-  },
-  "standard-version": {
-    "skip": {
-      "tag": true,
-      "commit": true
-    }
+  "scripts": {
+    "test": "jest",
+    "clean:turbo": "rss",
+    "clean:build": "rss",
+    "clean": "rss",
+    "build:less": "rss",
+    "build:esm": "rss",
+    "build:cjs": "rss",
+    "build:umd": "rollup -c ./rollup.config.js --bundleConfigAsCjs",
+    "build:dev": "run-p -s build:cjs build:esm",
+    "build:watch": "rss",
+    "build:watch:esm": "rss",
+    "build:watch:cjs": "rss",
+    "build": "rss",
+    "prebuild": "rss"
   },
   "keywords": [
     "logicflow",
     "workflow",
-    "process",
-    "diagram"
+    "process engine"
   ],
-  "devDependencies": {
-    "@babel/core": "^7.9.0",
-    "@babel/plugin-proposal-decorators": "^7.12.1",
-    "@babel/plugin-syntax-jsx": "^7.8.3",
-    "@babel/plugin-transform-react-jsx": "^7.10.4",
-    "@babel/preset-env": "^7.9.5",
-    "@babel/preset-typescript": "^7.9.0",
-    "@commitlint/config-conventional": "^8.3.4",
-    "@typescript-eslint/eslint-plugin": "^4.7.0",
-    "@typescript-eslint/parser": "^3.2.0",
-    "babel-core": "^7.0.0-bridge.0",
-    "babel-loader": "^8.1.0",
-    "babel-plugin-import": "^1.13.0",
-    "case-sensitive-paths-webpack-plugin": "^2.3.0",
-    "core-js": "^3.6.5",
-    "cross-env": "^7.0.2",
-    "css-loader": "^4.2.1",
-    "eslint": "^7.0.0",
-    "eslint-config-airbnb-typescript": "^9.0.0",
-    "eslint-plugin-import": "^2.22.0",
-    "eslint-plugin-jsx-a11y": "^6.3.1",
-    "eslint-plugin-react": "^7.20.6",
-    "eslint-plugin-standard": "^4.0.1",
-    "eslint-webpack-plugin": "^2.1.0",
-    "html-webpack-plugin": "^4.2.0",
-    "less-loader": "^6.0.0",
-    "prettier": "^2.2.1",
-    "rimraf": "^3.0.2",
-    "standard-version": "^9.0.0",
-    "style-loader": "^1.2.0",
-    "typescript": "^3.8.3",
-    "url-loader": "^4.1.0",
-    "webpack": "^4.43.0",
-    "webpack-bundle-analyzer": "^4.1.0",
-    "webpack-cli": "^3.3.11",
-    "webpack-dev-server": "^3.10.3"
+  "author": "Logicflow-Team",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "uuid": "^8.2.0"
   },
-  "gitHead": "ab8cc6126e9dfa5c4fb18037538a374d3a0b0521"
+  "devDependencies": {
+    "tslib": "^2.6.1"
+  }
 }

package/src/EventEmitter.ts

@@ -0,0 +1,103 @@
+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: EventsType
+  constructor() {
+    this._events = {}
+  }
+
+  /**
+   * 添加一个监听事件
+   * @param evtKey 事件名称
+   * @param callback 回调方法
+   * @param once 是否触发一次
+   * @returns 当前 EventEmitter 实例
+   */
+  on(evtKey: string, callback: CallbackType, once?: boolean) {
+    evtKey = evtKey.trim()
+    if (!this._events[evtKey]) {
+      this._events[evtKey] = []
+    }
+    this._events[evtKey].push({
+      callback,
+      once: !!once,
+    })
+  }
+
+  /**
+   * 取消监听一个事件，或者一个 Channel
+   * @param evtKey
+   * @param callback
+   */
+  off(evtKey: string, callback?: CallbackType) {
+    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: string, eventArgs: 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
+  }
+}
+
+export { EventEmitter }

package/src/FlowModel.ts

@@ -0,0 +1,325 @@
+import { Engine } from '.'
+import { Recorder } from './recorder'
+import { Scheduler } from './Scheduler'
+import { BaseNode } from './nodes'
+import { createExecId } from './utils'
+import {
+  EVENT_INSTANCE_COMPLETE,
+  EVENT_INSTANCE_INTERRUPTED,
+  EVENT_INSTANCE_ERROR,
+} from './constant'
+import { ErrorCode, getErrorMsg } from './constant/logCode'
+
+export 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> = new Map()
+  /**
+   * 当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
+   */
+  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 = 'StartNode',
+  }: FlowModel.IFlowModelProps) {
+    // 流程包含的节点类型 ??? 在 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({
+      flowModel: this,
+      recorder,
+    })
+
+    this.scheduler.on(EVENT_INSTANCE_COMPLETE, (result) => {
+      this.onExecuteFinished(result)
+    })
+
+    this.scheduler.on(EVENT_INSTANCE_INTERRUPTED, (result) => {
+      this.onExecuteFinished(result)
+    })
+
+    this.scheduler.on(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 流程图数据
+   */
+  public load(graphData: Engine.GraphConfigData) {
+    const { nodes = [], edges = [] } = graphData
+    nodes.forEach((node) => {
+      if (this.nodeModelMap.has(node.type)) {
+        const nodeConfig: BaseNode.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
+   */
+  private createExecution(execParam: Partial<FlowModel.ExecParam>) {
+    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 = createExecId()
+    execParam.executionId = executionId
+
+    // 当指定了具体需要执行的节点时，执行下面方法
+    if (execParam?.nodeId) {
+      const nodeConfig = this.nodeConfigMap.get(execParam.nodeId)
+      if (!nodeConfig) {
+        execParam?.onError?.(
+          new Error(
+            `${getErrorMsg(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
+   */
+  public async execute(params: Partial<FlowModel.ExecParam>) {
+    this.createExecution(params)
+  }
+
+  public async resume(params: Partial<FlowModel.ExecParam>) {
+    this.createExecution(params)
+  }
+
+  /**
+   * 创建节点实例，每个节点实例都会有一个唯一的 actionId
+   * 通过 executionId, nodeId, actionId 可以唯一确定一个节点的某一次执行
+   * @param nodeId
+   * @returns 节点实例
+   */
+  // TODO: 确认下面这种场景，类型如何定义
+  public createAction(nodeId: Engine.Key) {
+    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,
+      })
+    }
+  }
+
+  public setStartNodeType(type: string) {
+    this.startNodeType = type
+  }
+
+  public updateGlobalData(data: Record<string, unknown>) {
+    // TODO: 数据的合并，是否考虑子项的合并（默认值的替换）
+    this.globalData = {
+      ...this.globalData,
+      ...data,
+    }
+    return this.globalData
+  }
+
+  /**
+   * 在执行完成后，通知外部此次之行完成
+   * 如果还存在待执行的任务，那么继续执行
+   * @param result
+   * @private
+   */
+  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?.(result)
+    }
+  }
+}
+
+export namespace FlowModel {
+  export type FlowResult =
+    | ({
+        result?: Record<string, unknown>
+      } & Engine.ActionParam)
+    | Engine.NextActionParam
+
+  export type ActionParam = Scheduler.ActionParam
+
+  export type ExecParam = {
+    callback?: (result: Engine.NextActionParam) => void
+    onError?: (error: Error) => void
+  } & ActionParam
+
+  export interface IFlowModelProps {
+    nodeModelMap: Map<string, BaseNode.NodeConstructor>
+    recorder?: Recorder
+    context?: Record<string, unknown>
+    globalData?: Record<string, unknown>
+    startNodeType?: string
+  }
+}
+
+export default FlowModel