liteflow-editor-process 1.0.0

package/dist/LiteFlowEditor/model/el/for-operator.js

@@ -0,0 +1,171 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Edge, Node } from '@antv/x6';
+import ELNode from "../node";
+import { ELEndNode } from "../utils";
+import { ConditionTypeEnum, LITEFLOW_EDGE, NODE_TYPE_INTERMEDIATE_END, NodeTypeEnum } from "../../constant";
+import NodeOperator from "./node-operator";
+
+/**
+ * 循环编排操作符：FOR。
+ *
+ * 例如一个FOR循环编排示例：
+ * (1) EL表达式语法：FOR(x).DO(THEN(a, b))
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.FOR,
+    condition: { type: NodeTypeEnum.FOR, id: 'x' },
+    children: [
+      {
+        type: ConditionTypeEnum.THEN,
+        children: [
+          { type: NodeTypeEnum.COMMON, id: 'a' },
+          { type: NodeTypeEnum.COMMON, id: 'b' },
+        ],
+      },
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘      ┌─────────────────┐
+  │  Chain  │───▶│   ForOperator   │──┤   ┌─────────────────┐  ┌──▶│  NodeOperator   │
+  └─────────┘    └─────────────────┘  └──▶│  ThenOperator   │──┤   └─────────────────┘
+                                          └─────────────────┘  │   ┌─────────────────┐
+                                                               └──▶│  NodeOperator   │
+                                                                   └─────────────────┘
+ */
+var ForOperator = /*#__PURE__*/function (_ELNode) {
+  _inherits(ForOperator, _ELNode);
+  var _super = _createSuper(ForOperator);
+  function ForOperator(parent, condition, children, properties) {
+    var _this;
+    _classCallCheck(this, ForOperator);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "type", ConditionTypeEnum.FOR);
+    _defineProperty(_assertThisInitialized(_this), "parent", void 0);
+    _defineProperty(_assertThisInitialized(_this), "condition", new NodeOperator(_assertThisInitialized(_this), NodeTypeEnum.FOR, 'x'));
+    _defineProperty(_assertThisInitialized(_this), "children", []);
+    _defineProperty(_assertThisInitialized(_this), "properties", void 0);
+    _defineProperty(_assertThisInitialized(_this), "startNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "endNode", void 0);
+    _this.parent = parent;
+    if (condition) {
+      _this.condition = condition;
+    }
+    if (children) {
+      _this.children = children;
+    }
+    _this.properties = properties;
+    return _this;
+  }
+
+  /**
+   * 创建新的节点
+   * @param parent 新节点的父节点
+   * @param type 新节点的子节点类型
+   */
+  _createClass(ForOperator, [{
+    key: "toCells",
+    value:
+    /**
+     * 转换为X6的图数据格式
+     */
+    function toCells() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.resetCells();
+      var condition = this.condition,
+        children = this.children,
+        cells = this.cells;
+      condition.toCells({
+        shape: NodeTypeEnum.FOR
+      });
+      var start = condition.getStartNode();
+      start.setData({
+        model: condition,
+        toolbar: {
+          prepend: true,
+          append: true,
+          delete: true,
+          replace: true,
+          collapse: true
+        }
+      }, {
+        overwrite: true
+      });
+      this.startNode = start;
+      start = condition.getEndNode();
+      if (!this.collapsed) {
+        var end = Node.create({
+          shape: NODE_TYPE_INTERMEDIATE_END,
+          attrs: {
+            label: {
+              text: ''
+            }
+          }
+        });
+        end.setData({
+          model: new ELEndNode(this)
+        }, {
+          overwrite: true
+        });
+        cells.push(this.addNode(end));
+        this.endNode = end;
+        if (children.length) {
+          children.forEach(function (child) {
+            child.toCells(options);
+            var nextStartNode = child.getStartNode();
+            cells.push(Edge.create({
+              shape: LITEFLOW_EDGE,
+              source: start.id,
+              target: nextStartNode.id
+            }));
+            var nextEndNode = child.getEndNode();
+            cells.push(Edge.create({
+              shape: LITEFLOW_EDGE,
+              source: nextEndNode.id,
+              target: end.id
+            }));
+          });
+        } else {
+          cells.push(Edge.create({
+            shape: LITEFLOW_EDGE,
+            source: start.id,
+            target: end.id
+          }));
+        }
+      }
+      return this.getCells();
+    }
+
+    /**
+     * 转换为EL表达式字符串
+     */
+  }, {
+    key: "toEL",
+    value: function toEL() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      if (prefix) {
+        return "".concat(prefix, "FOR(").concat(this.condition.toEL(), ").DO(\n").concat(this.children.map(function (x) {
+          return x.toEL("".concat(prefix, "  "));
+        }).join(', \n'), "\n").concat(prefix, ")");
+      }
+      return "FOR(".concat(this.condition.toEL(), ").DO(").concat(this.children.map(function (x) {
+        return x.toEL();
+      }).join(', '), ")");
+    }
+  }], [{
+    key: "create",
+    value: function create(parent, type) {
+      var newNode = new ForOperator(parent);
+      newNode.appendChild(NodeOperator.create(newNode, type));
+      return newNode;
+    }
+  }]);
+  return ForOperator;
+}(ELNode);
+export { ForOperator as default };

package/dist/LiteFlowEditor/model/el/if-operator.d.ts

@@ -0,0 +1,64 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode, { Properties } from '../node';
+import { ConditionTypeEnum, NodeTypeEnum } from '../../constant';
+/**
+ * 条件编排操作符：IF。
+ *
+ * 例如一个条件编排(IF)示例：
+ * (1) EL表达式语法：IF(x, a)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.IF,
+    condition: { type: NodeTypeEnum.IF, id: 'x' },
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'a' }
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘
+  │  Chain  │───▶│    IfOperator   │──┤   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  └──▶│  NodeOperator   │
+                                          └─────────────────┘
+ */
+export default class IfOperator extends ELNode {
+    type: ConditionTypeEnum;
+    parent?: ELNode;
+    condition: ELNode;
+    children: ELNode[];
+    properties?: Properties;
+    startNode?: Node;
+    endNode?: Node;
+    constructor(parent?: ELNode, condition?: ELNode, children?: ELNode[], properties?: Properties);
+    /**
+     * 创建新的节点
+     * @param parent 新节点的父节点
+     * @param type 新节点的子节点类型
+     */
+    static create(parent?: ELNode, type?: NodeTypeEnum): ELNode;
+    /**
+     * 转换为X6的图数据格式
+     */
+    toCells(options?: Record<string, any>): Cell[];
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+    appendChild(newNode: ELNode): boolean;
+    appendChild(newNode: ELNode, index: number): boolean;
+    appendChild(newNode: ELNode, sibling: ELNode): boolean;
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+    prependChild(newNode: ELNode): boolean;
+    prependChild(newNode: ELNode, index: number): boolean;
+    prependChild(newNode: ELNode, sibling: ELNode): boolean;
+    /**
+     * 转换为EL表达式字符串
+     */
+    toEL(prefix?: string): string;
+}

package/dist/LiteFlowEditor/model/el/if-operator.js

@@ -0,0 +1,265 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Node, Edge } from '@antv/x6';
+import ELNode from "../node";
+import { ELEndNode, ELVirtualNode, generateUniqueId } from "../utils";
+import { ConditionTypeEnum, LITEFLOW_EDGE, NODE_TYPE_INTERMEDIATE_END, NodeTypeEnum } from "../../constant";
+import NodeOperator from "./node-operator";
+
+/**
+ * 条件编排操作符：IF。
+ *
+ * 例如一个条件编排(IF)示例：
+ * (1) EL表达式语法：IF(x, a)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.IF,
+    condition: { type: NodeTypeEnum.IF, id: 'x' },
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'a' }
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐
+                                      ┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘
+  │  Chain  │───▶│    IfOperator   │──┤   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  └──▶│  NodeOperator   │
+                                          └─────────────────┘
+ */
+var IfOperator = /*#__PURE__*/function (_ELNode) {
+  _inherits(IfOperator, _ELNode);
+  var _super = _createSuper(IfOperator);
+  function IfOperator(parent, condition, children, properties) {
+    var _this;
+    _classCallCheck(this, IfOperator);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "type", ConditionTypeEnum.IF);
+    _defineProperty(_assertThisInitialized(_this), "parent", void 0);
+    _defineProperty(_assertThisInitialized(_this), "condition", new NodeOperator(_assertThisInitialized(_this), NodeTypeEnum.IF, 'x'));
+    _defineProperty(_assertThisInitialized(_this), "children", []);
+    _defineProperty(_assertThisInitialized(_this), "properties", void 0);
+    _defineProperty(_assertThisInitialized(_this), "startNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "endNode", void 0);
+    _this.parent = parent;
+    if (condition) {
+      _this.condition = condition;
+    }
+    if (children) {
+      _this.children = children;
+    }
+    _this.properties = properties;
+    return _this;
+  }
+
+  /**
+   * 创建新的节点
+   * @param parent 新节点的父节点
+   * @param type 新节点的子节点类型
+   */
+  _createClass(IfOperator, [{
+    key: "toCells",
+    value:
+    /**
+     * 转换为X6的图数据格式
+     */
+    function toCells() {
+      var _this2 = this;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.resetCells();
+      var condition = this.condition,
+        _this$children = this.children,
+        children = _this$children === void 0 ? [] : _this$children,
+        cells = this.cells;
+      condition.toCells({
+        shape: NodeTypeEnum.IF
+      });
+      var start = condition.getStartNode();
+      start.setData({
+        model: condition,
+        toolbar: {
+          prepend: true,
+          append: false,
+          delete: true,
+          replace: true,
+          collapse: true
+        }
+      }, {
+        overwrite: true
+      });
+      this.startNode = start;
+      start = condition.getEndNode();
+      if (!this.collapsed) {
+        var end = Node.create({
+          shape: NODE_TYPE_INTERMEDIATE_END,
+          attrs: {
+            label: {
+              text: ''
+            }
+          }
+        });
+        end.setData({
+          model: new ELEndNode(this),
+          toolbar: {
+            prepend: false,
+            append: true,
+            delete: true,
+            replace: true
+          }
+        }, {
+          overwrite: true
+        });
+        cells.push(this.addNode(end));
+        this.endNode = end;
+        var _children = _slicedToArray(children, 2),
+          trueNode = _children[0],
+          falseNode = _children[1];
+        [trueNode, falseNode].forEach(function (item, index) {
+          var next = item || NodeOperator.create(_this2, NodeTypeEnum.VIRTUAL, ' ');
+          next.toCells(options);
+          var nextStartNode = next.getStartNode();
+          cells.push(Edge.create({
+            shape: LITEFLOW_EDGE,
+            source: start.id,
+            target: nextStartNode.id,
+            label: index ? 'false' : 'true'
+          }));
+          var nextEndNode = next.getEndNode();
+          cells.push(Edge.create({
+            shape: LITEFLOW_EDGE,
+            source: nextEndNode.id,
+            target: end.id,
+            label: ' '
+          }));
+          if (!item) {
+            nextStartNode.setData({
+              model: new ELVirtualNode(_this2, index, next),
+              toolbar: {
+                prepend: false,
+                append: false,
+                delete: false,
+                replace: true
+              }
+            }, {
+              overwrite: true
+            });
+            cells.push(_this2.addNode(nextStartNode));
+          }
+        });
+      }
+      return this.getCells();
+    }
+
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+  }, {
+    key: "appendChild",
+    value: function appendChild(newNode, index) {
+      newNode.parent = this;
+      if (this.children) {
+        // 尝试在父节点中添加新节点
+        if (typeof index === 'number') {
+          // 1. 如果有索引
+          // this.children.splice(index, this.children[index] ? 1: 0, newNode);
+          this.children[index <= 1 ? index : 1] = newNode;
+          return true;
+        }
+        if (index) {
+          // 2. 如果有目标节点
+          var _index = this.children.indexOf(index);
+          if (_index !== -1) {
+            // this.children.splice(_index + 1, this.children[_index] ? 1: 0, newNode);
+            this.children[_index <= 1 ? _index : 1] = newNode;
+            return true;
+          }
+          // 3. 如果是在condition之后追加
+          if (this.condition === index) {
+            return this.appendChild(newNode, 0);
+          }
+        }
+        // 4. 否则直接插入
+        this.children.push(newNode);
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+  }, {
+    key: "prependChild",
+    value: function prependChild(newNode, index) {
+      newNode.parent = this;
+      if (this.children) {
+        // 尝试在父节点中添加新节点
+        if (typeof index === 'number') {
+          // 1. 如果有索引
+          // this.children.splice(index, this.children[index] ? 1: 0, newNode);
+          this.children[index] = newNode;
+          return true;
+        }
+        if (index) {
+          // 2. 如果有目标节点
+          var _index = this.children.indexOf(index);
+          if (_index !== -1) {
+            // this.children.splice(_index, this.children[_index] ? 1: 0, newNode);
+            this.children[_index] = newNode;
+            return true;
+          }
+          if (this.condition === index) {
+            // 3. 如果是在condition之前追加
+            return this.prepend(newNode);
+          }
+        }
+        // 4. 否则直接插入
+        this.children.splice(0, this.children[0] ? 1 : 0, newNode);
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * 转换为EL表达式字符串
+     */
+  }, {
+    key: "toEL",
+    value: function toEL() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      if (prefix) {
+        return "".concat(prefix, "IF(\n").concat([this.condition.toEL("".concat(prefix, "  "))].concat(_toConsumableArray(this.children.filter(function (x) {
+          return x;
+        }).map(function (x) {
+          return x.toEL("".concat(prefix, "  "));
+        }))).join(', \n'), "\n").concat(prefix, ")").concat(this.propertiesToEL());
+      }
+      return "IF(".concat([this.condition.toEL()].concat(_toConsumableArray(this.children.filter(function (x) {
+        return x;
+      }).map(function (x) {
+        return x.toEL();
+      }))).join(', '), ")").concat(this.propertiesToEL());
+    }
+  }], [{
+    key: "create",
+    value: function create(parent, type) {
+      var newNode = new IfOperator(parent);
+      newNode.appendChild(NodeOperator.create(newNode, type, undefined, {
+        tag: generateUniqueId()
+      }));
+      return newNode;
+    }
+  }]);
+  return IfOperator;
+}(ELNode);
+export { IfOperator as default };

package/dist/LiteFlowEditor/model/el/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * EL表达式各个操作符模型，继承关系为：
+                      ┌─────────────────┐
+                  ┌──▶│  ThenOperator   │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  WhenOperator   │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  SwitchOperator │
+                  │   └─────────────────┘
+  ┌──────────┐    │   ┌─────────────────┐
+  │  ELNode  │────┼──▶│  IfOperator     │
+  └──────────┘    │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  ForOperator    │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  WhileOperator  │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  CatchOperator  │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  └──▶│  NodeOperator   │
+                      └─────────────────┘
+ */
+export { default as ThenOperator } from './then-operator';
+export { default as WhenOperator } from './when-operator';
+export { default as SwitchOperator } from './switch-operator';
+export { default as IfOperator } from './if-operator';
+export { default as ForOperator } from './for-operator';
+export { default as WhileOperator } from './while-operator';
+export { default as IteratorOperator } from './iterator-operator';
+export { default as CatchOperator } from './catch-operator';
+export { default as AndOperator } from './and-operator';
+export { default as OrOperator } from './or-operator';
+export { default as NotOperator } from './not-operator';
+export { default as NodeOperator } from './node-operator';
+export { default as ChainOperator } from './chain-operator';

package/dist/LiteFlowEditor/model/el/index.js

@@ -0,0 +1,47 @@
+/**
+ * EL表达式各个操作符模型，继承关系为：
+                      ┌─────────────────┐
+                  ┌──▶│  ThenOperator   │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  WhenOperator   │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  SwitchOperator │
+                  │   └─────────────────┘
+  ┌──────────┐    │   ┌─────────────────┐
+  │  ELNode  │────┼──▶│  IfOperator     │
+  └──────────┘    │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  ForOperator    │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  WhileOperator  │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  ├──▶│  CatchOperator  │
+                  │   └─────────────────┘
+                  │   ┌─────────────────┐
+                  └──▶│  NodeOperator   │
+                      └─────────────────┘
+ */
+// 1. 顺序类
+export { default as ThenOperator } from "./then-operator";
+export { default as WhenOperator } from "./when-operator";
+// 2. 分支类
+export { default as SwitchOperator } from "./switch-operator";
+export { default as IfOperator } from "./if-operator";
+// 3. 循环类
+export { default as ForOperator } from "./for-operator";
+export { default as WhileOperator } from "./while-operator";
+export { default as IteratorOperator } from "./iterator-operator";
+// 4. 捕获异常
+export { default as CatchOperator } from "./catch-operator";
+// 5. 运算符
+export { default as AndOperator } from "./and-operator";
+export { default as OrOperator } from "./or-operator";
+export { default as NotOperator } from "./not-operator";
+// 6. 节点类
+export { default as NodeOperator } from "./node-operator";
+// 7. 子流程
+export { default as ChainOperator } from "./chain-operator";

package/dist/LiteFlowEditor/model/el/iterator-operator.d.ts

@@ -0,0 +1,56 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode, { Properties } from '../node';
+import { ConditionTypeEnum, NodeTypeEnum } from '../../constant';
+/**
+ * Iterator编排操作符：ITERATOR。
+ *
+ * 例如一个ITERATOR循环编排示例：
+ * (1) EL表达式语法：ITERATOR(x).DO(THEN(a, b))
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.ITERATOR,
+    condition: { type: NodeTypeEnum.ITERATOR, id: 'x' },
+    children: [
+      {
+        type: ConditionTypeEnum.THEN,
+        children: [
+          { type: NodeTypeEnum.COMMON, id: 'a' },
+          { type: NodeTypeEnum.COMMON, id: 'b' },
+        ],
+      },
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                           ┌─────────────────┐
+                                       ┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌──────────────────┐  │   └─────────────────┘      ┌─────────────────┐
+  │  Chain  │───▶│ IteratorOperator │──┤   ┌─────────────────┐  ┌──▶│  NodeOperator   │
+  └─────────┘    └──────────────────┘  └──▶│  ThenOperator   │──┤   └─────────────────┘
+                                           └─────────────────┘  │   ┌─────────────────┐
+                                                                └──▶│  NodeOperator   │
+                                                                    └─────────────────┘
+ */
+export default class IteratorOperator extends ELNode {
+    type: ConditionTypeEnum;
+    parent?: ELNode;
+    condition: ELNode;
+    children: ELNode[];
+    properties?: Properties;
+    startNode?: Node;
+    endNode?: Node;
+    constructor(parent?: ELNode, condition?: ELNode, children?: ELNode[], properties?: Properties);
+    /**
+     * 创建新的节点
+     * @param parent 新节点的父节点
+     * @param type 新节点的子节点类型
+     */
+    static create(parent?: ELNode, type?: NodeTypeEnum): ELNode;
+    /**
+     * 转换为X6的图数据格式
+     */
+    toCells(options?: Record<string, any>): Cell[];
+    /**
+     * 转换为EL表达式字符串
+     */
+    toEL(prefix?: string): string;
+}