liteflow-editor-process 1.0.0

package/dist/LiteFlowEditor/mock/index.js

@@ -0,0 +1,272 @@
+import { ConditionTypeEnum, NodeTypeEnum } from "../constant";
+export default {
+  // 串行编排(THEN)
+  THEN: {
+    type: ConditionTypeEnum.THEN,
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'a'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'b'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'c'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'd'
+    }]
+  },
+  // 并行编排(WHEN)
+  WHEN: {
+    type: ConditionTypeEnum.THEN,
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'a'
+    }, {
+      type: ConditionTypeEnum.WHEN,
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'b'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'c'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'd'
+      }]
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'e'
+    }]
+  },
+  // 选择编排(SWITCH)
+  SWITCH: {
+    type: ConditionTypeEnum.SWITCH,
+    condition: {
+      type: NodeTypeEnum.SWITCH,
+      id: 'x'
+    },
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'a'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'b'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'c'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'd'
+    }]
+  },
+  // 条件编排(IF)
+  IF: {
+    type: ConditionTypeEnum.IF,
+    condition: {
+      type: NodeTypeEnum.BOOLEAN,
+      id: 'x'
+    },
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'a'
+    }]
+  },
+  // FOR循环
+  FOR: {
+    type: ConditionTypeEnum.FOR,
+    condition: {
+      type: NodeTypeEnum.BOOLEAN,
+      id: 'x'
+    },
+    children: [{
+      type: ConditionTypeEnum.THEN,
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'a'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'b'
+      }]
+    }]
+  },
+  // WHILE循环
+  WHILE: {
+    type: ConditionTypeEnum.WHILE,
+    condition: {
+      type: NodeTypeEnum.BOOLEAN,
+      id: 'x'
+    },
+    children: [{
+      type: ConditionTypeEnum.THEN,
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'a'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'b'
+      }]
+    }]
+  },
+  // ITERATOR循环
+  ITERATOR: {
+    type: ConditionTypeEnum.ITERATOR,
+    condition: {
+      type: NodeTypeEnum.ITERATOR,
+      id: 'x'
+    },
+    children: [{
+      type: ConditionTypeEnum.THEN,
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'a'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'b'
+      }]
+    }]
+  },
+  // CATCH 捕获异常
+  CATCH: {
+    type: ConditionTypeEnum.CATCH,
+    condition: {
+      type: ConditionTypeEnum.WHEN,
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'a'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'b'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'c'
+      }]
+    },
+    children: [{
+      type: ConditionTypeEnum.IF,
+      condition: {
+        type: NodeTypeEnum.IF,
+        id: 'x'
+      },
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'y'
+      }]
+    }]
+  },
+  // AND_OR_NOT 与或非
+  AND: {
+    type: ConditionTypeEnum.IF,
+    condition: {
+      type: ConditionTypeEnum.AND,
+      children: [{
+        type: ConditionTypeEnum.OR,
+        children: [{
+          type: NodeTypeEnum.BOOLEAN,
+          id: 'a'
+        }, {
+          type: NodeTypeEnum.BOOLEAN,
+          id: 'b'
+        }]
+      }, {
+        type: ConditionTypeEnum.NOT,
+        children: [{
+          type: NodeTypeEnum.BOOLEAN,
+          id: 'c'
+        }]
+      }]
+    },
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'x'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'y'
+    }]
+  },
+  // CHAIN 子流程
+  CHAIN: {
+    type: ConditionTypeEnum.THEN,
+    children: [{
+      type: NodeTypeEnum.COMMON,
+      id: 'A'
+    }, {
+      type: NodeTypeEnum.COMMON,
+      id: 'B'
+    }, {
+      type: ConditionTypeEnum.WHEN,
+      children: [{
+        type: ConditionTypeEnum.CHAIN,
+        id: 't1',
+        children: [{
+          type: ConditionTypeEnum.THEN,
+          children: [{
+            type: NodeTypeEnum.COMMON,
+            id: 'C'
+          }, {
+            type: ConditionTypeEnum.WHEN,
+            children: [{
+              type: NodeTypeEnum.COMMON,
+              id: 'J'
+            }, {
+              type: NodeTypeEnum.COMMON,
+              id: 'K'
+            }]
+          }]
+        }]
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'D'
+      }, {
+        type: ConditionTypeEnum.CHAIN,
+        id: 't2',
+        children: [{
+          type: ConditionTypeEnum.THEN,
+          children: [{
+            type: NodeTypeEnum.COMMON,
+            id: 'H'
+          }, {
+            type: NodeTypeEnum.COMMON,
+            id: 'I'
+          }]
+        }]
+      }]
+    }, {
+      type: ConditionTypeEnum.SWITCH,
+      condition: {
+        type: NodeTypeEnum.COMMON,
+        id: 'X'
+      },
+      children: [{
+        type: NodeTypeEnum.COMMON,
+        id: 'M'
+      }, {
+        type: NodeTypeEnum.COMMON,
+        id: 'N'
+      }, {
+        type: ConditionTypeEnum.CHAIN,
+        id: 'w1',
+        children: [{
+          type: ConditionTypeEnum.WHEN,
+          children: [{
+            type: NodeTypeEnum.COMMON,
+            id: 'Q'
+          }, {
+            type: ConditionTypeEnum.THEN,
+            children: [{
+              type: NodeTypeEnum.COMMON,
+              id: 'P'
+            }, {
+              type: NodeTypeEnum.COMMON,
+              id: 'R'
+            }]
+          }],
+          properties: {
+            id: 'w01'
+          }
+        }]
+      }]
+    }]
+  }
+};

package/dist/LiteFlowEditor/model/builder.d.ts

@@ -0,0 +1,43 @@
+import { ConditionTypeEnum, NodeTypeEnum } from '../constant';
+import ELNode from './node';
+interface ParseParameters {
+    data: Record<string, any>;
+    parent: ELNode;
+    type?: NodeTypeEnum | ConditionTypeEnum;
+}
+/**
+ * 将EL表达式的JSON表示，构造成ELNode模型表示。
+ * EL表达式的模型表示：数据结构本质上是一个树形结构。
+ * 例如一个串行编排(THEN)：
+ * (1) EL表达式形式：THEN(a, b, c, d)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.THEN,
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'a' },
+      { type: NodeTypeEnum.COMMON, id: 'b' },
+      { type: NodeTypeEnum.COMMON, id: 'c' },
+      { type: NodeTypeEnum.COMMON, id: 'd' },
+    ],
+  }
+ * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      ├──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘
+  │  Chain  │───▶│  ThenOperator   │──┤   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  ├──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      └──▶│  NodeOperator   │
+                                          └─────────────────┘
+ */
+export default class ELBuilder {
+    static build(data: Record<string, any> | Record<string, any>[]): ELNode;
+    static createELNode(type: ConditionTypeEnum | NodeTypeEnum, parent?: ELNode, id?: string): ELNode;
+}
+export declare function builder(data: Record<string, any> | Record<string, any>[]): ELNode;
+export declare function parse({ parent, data }: ParseParameters): ELNode | undefined;
+export {};

package/dist/LiteFlowEditor/model/builder.js

@@ -0,0 +1,239 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import Chain from "./chain";
+import { AndOperator, CatchOperator, ForOperator, IfOperator, IteratorOperator, NodeOperator, NotOperator, OrOperator, SwitchOperator, ThenOperator, WhenOperator, WhileOperator, ChainOperator } from "./el";
+import { ConditionTypeEnum, NodeTypeEnum } from "../constant";
+import { generateUniqueId } from "./utils";
+/**
+ * 将EL表达式的JSON表示，构造成ELNode模型表示。
+ * EL表达式的模型表示：数据结构本质上是一个树形结构。
+ * 例如一个串行编排(THEN)：
+ * (1) EL表达式形式：THEN(a, b, c, d)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.THEN,
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'a' },
+      { type: NodeTypeEnum.COMMON, id: 'b' },
+      { type: NodeTypeEnum.COMMON, id: 'c' },
+      { type: NodeTypeEnum.COMMON, id: 'd' },
+    ],
+  }
+ * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      ├──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘
+  │  Chain  │───▶│  ThenOperator   │──┤   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  ├──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      └──▶│  NodeOperator   │
+                                          └─────────────────┘
+ */
+var ELBuilder = /*#__PURE__*/function () {
+  function ELBuilder() {
+    _classCallCheck(this, ELBuilder);
+  }
+  _createClass(ELBuilder, null, [{
+    key: "build",
+    value: function build(data) {
+      return builder(data);
+    }
+  }, {
+    key: "createELNode",
+    value: function createELNode(type, parent, id) {
+      switch (type) {
+        // 1. 编排类型
+        case ConditionTypeEnum.THEN:
+        case ConditionTypeEnum.SER:
+          return ThenOperator.create(parent);
+        case ConditionTypeEnum.WHEN:
+        case ConditionTypeEnum.PAR:
+          return WhenOperator.create(parent);
+        case ConditionTypeEnum.SWITCH:
+          return SwitchOperator.create(parent);
+        case ConditionTypeEnum.IF:
+          return IfOperator.create(parent);
+        case ConditionTypeEnum.FOR:
+          return ForOperator.create(parent);
+        case ConditionTypeEnum.WHILE:
+          return WhileOperator.create(parent);
+        case ConditionTypeEnum.ITERATOR:
+          return IteratorOperator.create(parent);
+        case ConditionTypeEnum.CATCH:
+          return CatchOperator.create(parent);
+        case ConditionTypeEnum.AND:
+          return AndOperator.create(parent);
+        case ConditionTypeEnum.OR:
+          return OrOperator.create(parent);
+        case ConditionTypeEnum.NOT:
+          return NotOperator.create(parent);
+        case ConditionTypeEnum.CHAIN:
+          return ChainOperator.create(parent);
+        case ConditionTypeEnum.PRE:
+        case ConditionTypeEnum.FINALLY:
+        case ConditionTypeEnum.BREAK:
+        case ConditionTypeEnum.ABSTRACT:
+        case ConditionTypeEnum.DEFAULT:
+          return ThenOperator.create(parent);
+        // 2. 节点类型
+        case NodeTypeEnum.COMMON:
+        default:
+          // return NodeOperator.create(parent, type as NodeTypeEnum);
+          return NodeOperator.create(parent, type, id, {
+            tag: generateUniqueId()
+          });
+      }
+    }
+  }]);
+  return ELBuilder;
+}();
+export { ELBuilder as default };
+export function builder(data) {
+  var chain = new Chain();
+  if (Array.isArray(data)) {
+    data.forEach(function (item) {
+      var next = parse({
+        parent: chain,
+        data: item
+      });
+      if (next) {
+        chain.appendChild(next);
+      }
+    });
+  } else {
+    var next = parse({
+      parent: chain,
+      data: data
+    });
+    if (next) {
+      chain.appendChild(next);
+    }
+  }
+  return chain;
+}
+export function parse(_ref) {
+  var parent = _ref.parent,
+    data = _ref.data;
+  if (!(data !== null && data !== void 0 && data.type)) {
+    return undefined;
+  }
+  switch (data.type) {
+    // 1、编排类：顺序、分支、循环
+    case ConditionTypeEnum.THEN:
+    case ConditionTypeEnum.SER:
+      return parseOperator({
+        parent: new ThenOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.WHEN:
+    case ConditionTypeEnum.PAR:
+      return parseOperator({
+        parent: new WhenOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.SWITCH:
+      return parseOperator({
+        parent: new SwitchOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.IF:
+      return parseOperator({
+        parent: new IfOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.FOR:
+      return parseOperator({
+        parent: new ForOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.WHILE:
+      return parseOperator({
+        parent: new WhileOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.ITERATOR:
+      return parseOperator({
+        parent: new IteratorOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.CATCH:
+      return parseOperator({
+        parent: new CatchOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.AND:
+      return parseOperator({
+        parent: new AndOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.OR:
+      return parseOperator({
+        parent: new OrOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.NOT:
+      return parseOperator({
+        parent: new NotOperator(parent),
+        data: data
+      });
+    case ConditionTypeEnum.CHAIN:
+      return parseOperator({
+        parent: new ChainOperator(parent, data.id),
+        data: data
+      });
+    case ConditionTypeEnum.PRE:
+    case ConditionTypeEnum.FINALLY:
+    case ConditionTypeEnum.BREAK:
+    case ConditionTypeEnum.ABSTRACT:
+    case ConditionTypeEnum.DEFAULT:
+      return parseOperator({
+        parent: new ThenOperator(parent),
+        data: data,
+        type: data.type
+      });
+    // 2、组件类：顺序、分支、循环
+    case NodeTypeEnum.COMMON:
+    default:
+      return new NodeOperator(parent, data.type, data.id, data.properties);
+  }
+}
+function parseOperator(_ref2) {
+  var parent = _ref2.parent,
+    data = _ref2.data,
+    type = _ref2.type;
+  var condition = data.condition,
+    _data$children = data.children,
+    children = _data$children === void 0 ? [] : _data$children,
+    properties = data.properties;
+  if (condition) {
+    var conditionNode = parse({
+      parent: parent,
+      data: condition
+    });
+    if (conditionNode) {
+      parent.condition = conditionNode;
+    }
+  }
+  if (children && children.length) {
+    children.forEach(function (child) {
+      var childNode = parse({
+        parent: parent,
+        data: child
+      });
+      if (childNode) {
+        parent.appendChild(childNode);
+      }
+    });
+  }
+  if (properties) {
+    parent.setProperties(properties);
+  }
+  if (type) {
+    parent.type = type;
+  }
+  return parent;
+}

package/dist/LiteFlowEditor/model/chain.d.ts

@@ -0,0 +1,83 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode from './node';
+import { ConditionTypeEnum } from '../constant';
+/**
+ * EL表达式的根节点——EL表达式的所有延伸内容，都是在根节点上开始的。
+ * 例如一个串行编排(THEN)：
+ * (1) EL表达式形式：THEN(a, b, c, d)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.THEN,
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'a' },
+      { type: NodeTypeEnum.COMMON, id: 'b' },
+      { type: NodeTypeEnum.COMMON, id: 'c' },
+      { type: NodeTypeEnum.COMMON, id: 'd' },
+    ],
+  }
+ * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      ├──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘
+  │  Chain  │───▶│  ThenOperator   │──┤   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  ├──▶│  NodeOperator   │
+                                      │   └─────────────────┘
+                                      │   ┌─────────────────┐
+                                      └──▶│  NodeOperator   │
+                                          └─────────────────┘
+ */
+export default class Chain extends ELNode {
+    type: ConditionTypeEnum;
+    children: ELNode[];
+    startNode?: Node;
+    endNode?: Node;
+    constructor(children?: ELNode[]);
+    /**
+     * 转换为X6的图数据格式
+     */
+    toCells(): Cell[];
+    /**
+     * 转换为EL表达式字符串
+     */
+    toEL(prefix?: string): string;
+    dataPropertyToEL(prefix?: string): string;
+    /**
+     * 转换为JSON格式
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * 在开始节点的后面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+    append(newNode: ELNode): boolean;
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+    appendChild(newNode: ELNode, index?: number | ELNode): boolean;
+    /**
+     * 在结束节点的前面、插入新节点
+     * @param child 新节点
+     * @returns
+     */
+    prepend(newNode: ELNode): boolean;
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+    prependChild(newNode: ELNode, index?: number | ELNode): boolean;
+    /**
+     * 对于根节点，只要添加了任何子节点，就自动包一层 THEN
+     */
+    addWrapperIfPossible(): void;
+    /**
+     * 根节点不允许删除
+     */
+    remove(): boolean;
+}