liteflow-editor-process 1.0.0

package/dist/LiteFlowEditor/model/chain.js

@@ -0,0 +1,278 @@
+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 _get from "@babel/runtime/helpers/esm/get";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+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 { ConditionTypeEnum, LITEFLOW_EDGE, NODE_TYPE_END, NODE_TYPE_START } from "../constant";
+import { ThenOperator } from "./el";
+import i18n from "../i18n";
+
+/**
+ * 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   │
+                                          └─────────────────┘
+ */
+var Chain = /*#__PURE__*/function (_ELNode) {
+  _inherits(Chain, _ELNode);
+  var _super = _createSuper(Chain);
+  function Chain(children) {
+    var _this;
+    _classCallCheck(this, Chain);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "type", ConditionTypeEnum.CHAIN);
+    _defineProperty(_assertThisInitialized(_this), "children", []);
+    _defineProperty(_assertThisInitialized(_this), "startNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "endNode", void 0);
+    if (children) {
+      _this.children = children;
+    }
+    return _this;
+  }
+
+  /**
+   * 转换为X6的图数据格式
+   */
+  _createClass(Chain, [{
+    key: "toCells",
+    value: function toCells() {
+      this.resetCells();
+      var cells = this.cells;
+      // 1. 首先：添加一个开始节点
+      var start = Node.create({
+        shape: NODE_TYPE_START,
+        attrs: {
+          label: {
+            text: i18n.t('start')
+          }
+        }
+      });
+      start.setData({
+        model: this,
+        toolbar: {
+          prepend: false,
+          append: true,
+          delete: false,
+          replace: false
+        }
+      }, {
+        overwrite: true
+      });
+      cells.push(start);
+      this.startNode = start;
+
+      // 2. 其次：解析已有的节点
+      var last = start;
+      this.children.forEach(function (x) {
+        x.toCells();
+        cells.push(Edge.create({
+          shape: LITEFLOW_EDGE,
+          source: last.id,
+          target: x.getStartNode().id
+        }));
+        last = x.getEndNode();
+      });
+
+      // 3. 最后：添加一个结束节点
+      var end = Node.create({
+        shape: NODE_TYPE_END,
+        attrs: {
+          label: {
+            text: i18n.t('end')
+          }
+        }
+      });
+      end.setData({
+        model: this,
+        toolbar: {
+          prepend: true,
+          append: false,
+          delete: false,
+          replace: false
+        }
+      }, {
+        overwrite: true
+      });
+      cells.push(end);
+      this.endNode = end;
+      cells.push(Edge.create({
+        shape: LITEFLOW_EDGE,
+        source: last.id,
+        target: end.id
+      }));
+      return this.getCells();
+    }
+
+    /**
+     * 转换为EL表达式字符串
+     */
+  }, {
+    key: "toEL",
+    value: function toEL() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return "".concat(this.dataPropertyToEL(prefix)).concat(this.children.map(function (x) {
+        return x.toEL(prefix);
+      }).join(', '), ";");
+    }
+  }, {
+    key: "dataPropertyToEL",
+    value: function dataPropertyToEL() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var dataProperties = [];
+      var next = [this];
+      var _loop = function _loop() {
+        var current = [];
+        next.forEach(function (item) {
+          var _properties$data, _properties$data2;
+          var properties = item.getProperties();
+          if ((_properties$data = properties.data) !== null && _properties$data !== void 0 && _properties$data.name && (_properties$data2 = properties.data) !== null && _properties$data2 !== void 0 && _properties$data2.value) {
+            dataProperties.push(properties.data);
+          }
+          if (item.condition) {
+            current.push(item.condition);
+          }
+          if (item.children && item.children.length) {
+            current = current.concat(item.children);
+          }
+        });
+        next = current;
+      };
+      while (next.length) {
+        _loop();
+      }
+      return dataProperties.map(function (dataProperty) {
+        return "".concat(prefix).concat(dataProperty.name || '', "=").concat(dataProperty.value || '', ";\n");
+      }).join('');
+    }
+
+    /**
+     * 转换为JSON格式
+     */
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      if (this.children.length) {
+        if (this.children.length === 1) {
+          return this.children[0].toJSON();
+        } else {
+          return this.children.map(function (child) {
+            return child.toJSON();
+          });
+        }
+      }
+      return {};
+    }
+
+    /**
+     * 在开始节点的后面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+  }, {
+    key: "append",
+    value: function append(newNode) {
+      if (this.children.length === 1) {
+        if (this.children[0].type === ConditionTypeEnum.THEN) {
+          return this.children[0].prependChild(newNode, 0);
+        }
+      }
+      return this.appendChild(newNode, 0);
+    }
+
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+  }, {
+    key: "appendChild",
+    value: function appendChild(newNode, index) {
+      var result = _get(_getPrototypeOf(Chain.prototype), "appendChild", this).call(this, newNode, index);
+      this.addWrapperIfPossible();
+      return result;
+    }
+
+    /**
+     * 在结束节点的前面、插入新节点
+     * @param child 新节点
+     * @returns
+     */
+  }, {
+    key: "prepend",
+    value: function prepend(newNode) {
+      if (this.children.length === 1) {
+        if (this.children[0].type === ConditionTypeEnum.THEN) {
+          return this.children[0].appendChild(newNode);
+        }
+      }
+      return this.appendChild(newNode);
+    }
+
+    /**
+     * 在后面添加子节点
+     * @param newNode 子节点
+     * @param index 指定位置：可以是索引，也可以是兄弟节点
+     */
+  }, {
+    key: "prependChild",
+    value: function prependChild(newNode, index) {
+      var result = _get(_getPrototypeOf(Chain.prototype), "prependChild", this).call(this, newNode, index);
+      this.addWrapperIfPossible();
+      return result;
+    }
+
+    /**
+     * 对于根节点，只要添加了任何子节点，就自动包一层 THEN
+     */
+  }, {
+    key: "addWrapperIfPossible",
+    value: function addWrapperIfPossible() {
+      // 如果已有一个子节点，且不是 ThenOperator，也需要包裹
+      if (this.children.length >= 1 && this.children[0].type !== ConditionTypeEnum.THEN) {
+        var wrapper = new ThenOperator(this, []);
+        this.children.forEach(function (child) {
+          wrapper.appendChild(child);
+        });
+        this.children = [wrapper];
+      }
+    }
+
+    /**
+     * 根节点不允许删除
+     */
+  }, {
+    key: "remove",
+    value: function remove() {
+      return false;
+    }
+  }]);
+  return Chain;
+}(ELNode);
+export { Chain as default };

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

@@ -0,0 +1,53 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode, { Properties } from '../node';
+import { ConditionTypeEnum, NodeTypeEnum } from '../../constant';
+/**
+ * 与操作符：AND。
+ *
+ * 例如一个与(AND)示例：
+ * (1) EL表达式语法：IF(AND(a, b)), c)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.IF,
+    condition: {
+      type: ConditionTypeEnum.AND,
+      children: [
+        { type: NodeTypeEnum.COMMON, id: 'a' },
+        { type: NodeTypeEnum.COMMON, id: 'b' }
+      ]
+    },
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'c' }
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐      ┌─────────────────┐
+                                      ┌──▶│  AndOperator    │──┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘  │   └─────────────────┘
+  │  Chain  │───▶│    IfOperator   │──┤   ┌─────────────────┐  │   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  └──▶│  NodeOperator   │  └──▶│  NodeOperator   │
+                                          └─────────────────┘      └─────────────────┘
+ */
+export default class AndOperator extends ELNode {
+    type: ConditionTypeEnum;
+    parent?: ELNode;
+    children: ELNode[];
+    properties?: Properties;
+    startNode?: Node;
+    endNode?: Node;
+    constructor(parent?: 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;
+}

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

@@ -0,0 +1,178 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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 { ELStartNode, ELEndNode } from "../utils";
+import { ConditionTypeEnum, LITEFLOW_EDGE, NODE_TYPE_INTERMEDIATE_END } from "../../constant";
+import NodeOperator from "./node-operator";
+
+/**
+ * 与操作符：AND。
+ *
+ * 例如一个与(AND)示例：
+ * (1) EL表达式语法：IF(AND(a, b)), c)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.IF,
+    condition: {
+      type: ConditionTypeEnum.AND,
+      children: [
+        { type: NodeTypeEnum.COMMON, id: 'a' },
+        { type: NodeTypeEnum.COMMON, id: 'b' }
+      ]
+    },
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'c' }
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐      ┌─────────────────┐
+                                      ┌──▶│  AndOperator    │──┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘  │   └─────────────────┘
+  │  Chain  │───▶│    IfOperator   │──┤   ┌─────────────────┐  │   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  └──▶│  NodeOperator   │  └──▶│  NodeOperator   │
+                                          └─────────────────┘      └─────────────────┘
+ */
+var AndOperator = /*#__PURE__*/function (_ELNode) {
+  _inherits(AndOperator, _ELNode);
+  var _super = _createSuper(AndOperator);
+  function AndOperator(parent, children, properties) {
+    var _this;
+    _classCallCheck(this, AndOperator);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "type", ConditionTypeEnum.AND);
+    _defineProperty(_assertThisInitialized(_this), "parent", void 0);
+    _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 (children) {
+      _this.children = children;
+    }
+    _this.properties = properties;
+    return _this;
+  }
+
+  /**
+   * 创建新的节点
+   * @param parent 新节点的父节点
+   * @param type 新节点的子节点类型
+   */
+  _createClass(AndOperator, [{
+    key: "toCells",
+    value:
+    /**
+     * 转换为X6的图数据格式
+     */
+    function toCells() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.resetCells();
+      var children = this.children,
+        cells = this.cells;
+      var start = Node.create(_objectSpread({
+        shape: ConditionTypeEnum.AND,
+        attrs: {
+          label: {
+            text: ''
+          }
+        }
+      }, options));
+      start.setData({
+        model: new ELStartNode(this),
+        toolbar: {
+          prepend: true,
+          append: true,
+          delete: true,
+          replace: true,
+          collapse: true
+        }
+      }, {
+        overwrite: true
+      });
+      cells.push(this.addNode(start));
+      this.startNode = start;
+      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();
+            var nextStartNode = child.getStartNode();
+            cells.push(Edge.create({
+              shape: LITEFLOW_EDGE,
+              source: start.id,
+              target: nextStartNode.id,
+              label: ' + ',
+              defaultLabel: {
+                position: {
+                  options: {
+                    keepGradient: false,
+                    ensureLegibility: false
+                  }
+                }
+              }
+            }));
+            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, "AND(\n").concat(this.children.map(function (x) {
+          return x.toEL("".concat(prefix, "  "));
+        }).join(', \n'), "\n").concat(prefix, ")").concat(this.propertiesToEL());
+      }
+      return "AND(".concat(this.children.map(function (x) {
+        return x.toEL();
+      }).join(', '), ")").concat(this.propertiesToEL());
+    }
+  }], [{
+    key: "create",
+    value: function create(parent, type) {
+      var newNode = new AndOperator(parent);
+      newNode.appendChild(NodeOperator.create(newNode, type));
+      return newNode;
+    }
+  }]);
+  return AndOperator;
+}(ELNode);
+export { AndOperator as default };

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

@@ -0,0 +1,81 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode, { Properties } from '../node';
+import { ConditionTypeEnum, NodeTypeEnum } from '../../constant';
+/**
+ * 捕获异常操作符：CATCH。
+ *
+ * 例如一个捕获异常(CATCH)示例：
+ * (1) EL表达式语法：CATCH(THEN(a, b)).DO(c)
+ * (2) JSON表示形式：
+ * {
+    type: ConditionTypeEnum.CATCH,
+    condition: {
+      type: NodeTypeEnum.THEN,
+      children: [
+        { type: NodeTypeEnum.COMMON, id: 'a' },
+        { type: NodeTypeEnum.COMMON, id: 'b' }
+      ]
+    },
+    children: [
+      { type: NodeTypeEnum.COMMON, id: 'c' }
+    ],
+  }
+  * (3) 通过ELNode节点模型进行表示的组合关系为：
+                                          ┌─────────────────┐      ┌─────────────────┐
+                                      ┌──▶│  ThenOperator   │──┌──▶│  NodeOperator   │
+  ┌─────────┐    ┌─────────────────┐  │   └─────────────────┘  │   └─────────────────┘
+  │  Chain  │───▶│  CatchOperator  │──┤   ┌─────────────────┐  │   ┌─────────────────┐
+  └─────────┘    └─────────────────┘  └──▶│  NodeOperator   │  └──▶│  NodeOperator   │
+                                          └─────────────────┘      └─────────────────┘
+
+
+ */
+export default class CatchOperator 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[];
+    /**
+     * 获取当前X6 Cell内容
+     */
+    getCells(): 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;
+    /**
+     * 删除指定的子节点
+     * @param child 子节点
+     */
+    removeChild(child: ELNode): boolean;
+    /**
+     * 转换为EL表达式字符串
+     */
+    toEL(prefix?: string): string;
+}