liteflow-editor-process 1.0.0

package/dist/LiteFlowEditor/model/node.js

@@ -0,0 +1,463 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/**
+ * 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 ELNode = /*#__PURE__*/function () {
+  function ELNode() {
+    _classCallCheck(this, ELNode);
+    // 节点类型：可以是编排类型，也可以是组件类型
+    // 当前节点的子节点：编排类型有子节点，组件类型没有子节点
+    _defineProperty(this, "children", void 0);
+    // 当前节点的父节点
+    _defineProperty(this, "parent", void 0);
+    // 判断类节点类型：主要用于SWITCH/IF/FOR/WHILE等编排类型
+    _defineProperty(this, "condition", void 0);
+    // 组件节点的id
+    _defineProperty(this, "id", void 0);
+    // 编排节点的属性：可以设置id/tag等等
+    _defineProperty(this, "properties", void 0);
+    // 当前节点的X6 Cell内容
+    _defineProperty(this, "cells", []);
+    // 当前节点的X6 Node内容
+    _defineProperty(this, "nodes", []);
+    // 代理节点
+    _defineProperty(this, "proxy", void 0);
+    // 当前操作符节点的开始节点
+    _defineProperty(this, "startNode", void 0);
+    // 当前操作符节点的结束节点
+    _defineProperty(this, "endNode", void 0);
+    // 是否折叠
+    _defineProperty(this, "collapsed", false);
+  }
+  _createClass(ELNode, [{
+    key: "appendChild",
+    value: function appendChild(newNode, index) {
+      newNode.parent = this;
+      if (this.children) {
+        // 尝试在父节点中添加新节点
+        if (typeof index === 'number') {
+          // 1. 如果有索引
+          this.children.splice(index, 0, newNode);
+          return true;
+        }
+        if (index) {
+          // 2. 如果有目标节点
+          var _index = this.children.indexOf(index);
+          if (_index !== -1) {
+            this.children.splice(_index + 1, 0, newNode);
+            return true;
+          }
+          if (this.condition === index) {
+            // 3. 如果是在condition之后追加
+            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, 0, newNode);
+          return true;
+        }
+        if (index) {
+          // 2. 如果有目标节点
+          var _index = this.children.indexOf(index);
+          if (_index !== -1) {
+            this.children.splice(_index, 0, newNode);
+            return true;
+          }
+          if (this.condition === index) {
+            // 3. 如果是在condition之前追加
+            return this.prepend(newNode);
+          }
+        }
+        // 4. 否则直接插入
+        this.children.splice(0, 0, newNode);
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * 删除指定的子节点
+     * @param child 子节点
+     */
+  }, {
+    key: "removeChild",
+    value: function removeChild(child) {
+      if (this.children) {
+        var _index2 = this.children.indexOf(child);
+        if (_index2 !== -1) {
+          this.children.splice(_index2, 1);
+          return true;
+        }
+      }
+      if (this.condition && this.condition === child) {
+        return this.remove();
+      }
+      return false;
+    }
+
+    /**
+     * 在当前节点的前面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+  }, {
+    key: "prepend",
+    value: function prepend(newNode) {
+      if (this.parent) {
+        if (this.parent.prependChild(newNode, this)) {
+          return true;
+        }
+      } else {
+        return this.prependChild(newNode);
+      }
+      return false;
+    }
+
+    /**
+     * 在当前节点的后面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+  }, {
+    key: "append",
+    value: function append(newNode) {
+      if (this.parent) {
+        if (this.parent.appendChild(newNode, this)) {
+          return true;
+        }
+      } else {
+        return this.appendChild(newNode);
+      }
+      return false;
+    }
+
+    /**
+     * 删除当前节点
+     */
+  }, {
+    key: "remove",
+    value: function remove() {
+      if (this.parent) {
+        return this.parent.removeChild(this);
+      }
+      return false;
+    }
+
+    /**
+     * 替换当前节点为新节点
+     * @param newNode 新节点
+     * @returns
+     */
+  }, {
+    key: "replace",
+    value: function replace(newNode) {
+      if (this.parent) {
+        this.parent.replaceChild(this, newNode);
+      }
+      return false;
+    }
+
+    /**
+     * 替换老节点为新节点
+     * @param oldNode 老节点
+     * @param newNode 新节点
+     */
+  }, {
+    key: "replaceChild",
+    value: function replaceChild(oldNode, newNode) {
+      newNode.parent = this;
+      if (this.children) {
+        // 尝试在子节点中查找老节点位置
+        var _index3 = this.children.indexOf(oldNode);
+        if (_index3 !== -1) {
+          this.children.splice(_index3, 1, newNode);
+          return true;
+        }
+      }
+      if (this.condition === oldNode) {
+        // 3. 如果是在condition之后追加
+        this.condition = newNode;
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * 转换为X6的图数据格式
+     */
+  }, {
+    key: "selectNodes",
+    value:
+    /**
+     * 获取需要选中的X6 Cell
+     */
+    function selectNodes() {
+      var _this$parent;
+      if (((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.condition) === this) {
+        return this.parent.getNodes();
+      }
+      return this.getNodes();
+    }
+
+    /**
+     * 获取当前X6 Node内容
+     */
+  }, {
+    key: "getNodes",
+    value: function getNodes() {
+      var nodes = _toConsumableArray(this.nodes);
+      if (this.condition) {
+        nodes = nodes.concat(this.condition.getNodes());
+      }
+      if (this.children && this.children.length) {
+        this.children.forEach(function (child) {
+          nodes = nodes.concat(child.getNodes());
+        });
+      }
+      return nodes;
+    }
+
+    /**
+     * 获取当前X6 Cell内容
+     */
+  }, {
+    key: "getCells",
+    value: function getCells() {
+      var cells = _toConsumableArray(this.cells);
+      if (this.condition) {
+        cells = cells.concat(this.condition.getCells());
+      }
+      if (this.children && this.children.length && !this.collapsed) {
+        this.children.forEach(function (child) {
+          cells = cells.concat(child.getCells());
+        });
+      }
+      return cells;
+    }
+
+    /**
+     * 重置当前存储的X6 Cell内容
+     */
+  }, {
+    key: "resetCells",
+    value: function resetCells(cells, nodes) {
+      this.cells = cells || [];
+      this.nodes = nodes || [];
+    }
+
+    /**
+     * 获取当前节点的开始节点
+     */
+  }, {
+    key: "getStartNode",
+    value: function getStartNode() {
+      return this.startNode;
+    }
+
+    /**
+     * 获取当前节点的结束节点
+     */
+  }, {
+    key: "getEndNode",
+    value: function getEndNode() {
+      return this.collapsed ? this.startNode : this.endNode;
+    }
+
+    /**
+     * 添加X6 Node相关内容
+     * @param node X6 节点
+     */
+  }, {
+    key: "addNode",
+    value: function addNode(node) {
+      this.nodes.push(node);
+      return node;
+    }
+
+    /**
+     * 获取属性
+     * @returns 属性
+     */
+  }, {
+    key: "getProperties",
+    value: function getProperties() {
+      var properties = this.properties || {};
+      Object.keys(properties).filter(function (key) {
+        return properties[key] === '' || properties[key] === null || key === 'logList' || key === 'inputParams';
+      }).forEach(function (key) {
+        return properties[key] = undefined;
+      });
+      return properties;
+    }
+
+    /**
+     * 设置属性
+     */
+  }, {
+    key: "setProperties",
+    value: function setProperties(properties) {
+      this.properties = properties;
+    }
+
+    /**
+     * 获取属性的EL表达式
+     * @returns 属性的EL表达式
+     */
+  }, {
+    key: "propertiesToEL",
+    value: function propertiesToEL() {
+      var properties = this.getProperties();
+      var noConcatList = ['scriptName', 'outputParams', 'reportMinioName', 'inputList', 'inputParams', 'logId', 'dataSetId', 'modelType', 'simpleQueryModel', 'aggList', 'knowledgeTreeData', 'aiKnowledgeFileList', 'aiKnowledgeFileId', 'filterParam', 'nodeFilters', 'applyList', 'sortCriteria', 'fieldSetting', 'filedSetting', 'aiNetSearch', 'logList', 'forecastId', 'curScheduleSet', 'propValue', 'rootCauseNode', 'rootCauseParam', 'analysisFieldTemplate'];
+      var propertiesFilter = Object.keys(properties).filter(function (key) {
+        return properties[key] !== undefined && !noConcatList.includes(key);
+      });
+      return propertiesFilter.map(function (key) {
+        if (key === 'bind') {
+          return ".".concat(key, "(\"set\",").concat(JSON.stringify(properties[key]), ")");
+        } else {
+          return ".".concat(key, "(").concat(propertyToString(properties[key]), ")");
+        }
+      }).join('');
+    }
+
+    /**
+     * 转换为EL表达式字符串
+     */
+  }, {
+    key: "toJSON",
+    value:
+    /**
+     * 转换为JSON格式
+     */
+    function toJSON() {
+      var type = this.type,
+        condition = this.condition,
+        children = this.children,
+        properties = this.properties,
+        id = this.id;
+      return Object.assign({
+        type: type
+      }, condition ? {
+        condition: condition.toJSON()
+      } : {}, children ? {
+        children: children.filter(function (x) {
+          return x;
+        }).map(function (child) {
+          return child.toJSON();
+        })
+      } : {}, id ? {
+        id: id
+      } : {}, properties ? {
+        properties: this.getProperties()
+      } : {});
+    }
+
+    /**
+     * 当前模型，是否是参数模型的父节点
+     * @param model 模型
+     * @returns
+     */
+  }, {
+    key: "isParentOf",
+    value: function isParentOf(model) {
+      var thisModel = this.proxy || this;
+      var nextModel = model.proxy || model;
+      while (nextModel) {
+        if (nextModel.parent === thisModel) {
+          return true;
+        }
+        nextModel = nextModel.parent;
+      }
+      return false;
+    }
+
+    /**
+     * 是否折叠
+     */
+  }, {
+    key: "isCollapsed",
+    value: function isCollapsed() {
+      var _this$parent2;
+      if (((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.condition) === this) {
+        return this.parent.isCollapsed();
+      }
+      return this.collapsed;
+    }
+
+    /**
+     * 折叠：展开、收起
+     */
+  }, {
+    key: "toggleCollapse",
+    value: function toggleCollapse(collapsed) {
+      var _this$parent3;
+      if (((_this$parent3 = this.parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.condition) === this) {
+        this.parent.toggleCollapse(collapsed);
+      }
+      var target = typeof collapsed !== 'boolean' ? !this.collapsed : collapsed;
+      this.collapsed = !!target;
+    }
+  }]);
+  return ELNode;
+}();
+/**
+ * EL表达式操作符可以设置的id和tag等等属性。
+ */
+export { ELNode as default };
+function propertyToString(propertyValue) {
+  if (typeof propertyValue === 'string') {
+    return "'".concat(propertyValue, "'");
+  }
+  if (_typeof(propertyValue) === 'object') {
+    return propertyValue.name || propertyValue;
+  }
+  return propertyValue;
+}

package/dist/LiteFlowEditor/model/utils/createTag.d.ts

@@ -0,0 +1 @@
+export declare const generateUniqueId: () => string;

package/dist/LiteFlowEditor/model/utils/createTag.js

@@ -0,0 +1,5 @@
+export var generateUniqueId = function generateUniqueId() {
+  var timestamp = Date.now().toString(36).slice(-4);
+  var randomStr = Math.random().toString(36).slice(2, 6);
+  return timestamp + randomStr;
+};

package/dist/LiteFlowEditor/model/utils/end.d.ts

@@ -0,0 +1,87 @@
+import { Cell, Node } from '@antv/x6';
+import ELNode, { Properties } from '../node';
+import { NodeTypeEnum } from '../../constant';
+/**
+ * 操作符中结束节点的模型（作为操作符模型的代理），
+ * 操作符包括WHEN、SWITCH、IF、FOR、WHILE、CATCH、AND、OR、NOT等等。
+ */
+export default class ELEndNode extends ELNode {
+    type: NodeTypeEnum;
+    /** 代理的节点组件 */
+    proxy: ELNode;
+    /** 代理节点组件的相关属性 */
+    parent?: ELNode;
+    constructor(proxy: ELNode);
+    /**
+     * 在结束节点的前面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+    prepend(newNode: ELNode): boolean;
+    /**
+     * 在结束节点的后面、插入新节点
+     * @param newNode 新节点
+     * @returns
+     */
+    append(newNode: ELNode): boolean;
+    /**
+     * 删除结束节点
+     */
+    remove(): boolean;
+    /**
+     * 替换当前节点为新节点
+     * @param newNode 新节点
+     * @returns
+     */
+    replace(newNode: ELNode): boolean;
+    /**
+     * 转换为X6的图数据格式
+     */
+    toCells(): Cell[];
+    /**
+     * 获取当前X6 Cell内容
+     */
+    getCells(): Cell[];
+    /**
+     * 获取当前X6 节点内容
+     */
+    getNodes(): Node[];
+    /**
+     * 获取当前节点的开始节点
+     */
+    getStartNode(): Node;
+    /**
+     * 获取当前节点的结束节点
+     */
+    getEndNode(): Node;
+    /**
+     * 获取属性
+     * @returns 属性
+     */
+    getProperties(): Properties;
+    /**
+     * 设置属性
+     */
+    setProperties(properties: Properties): void;
+    /**
+     * 获取属性的EL表达式
+     * @returns 属性的EL表达式
+     */
+    propertiesToEL(): string;
+    /**
+     * 转换为EL表达式字符串
+     */
+    toEL(prefix?: string): string;
+    /**
+     * 转换为JSON格式
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * 是否折叠
+     */
+    isCollapsed(): boolean;
+    /**
+     * 折叠：展开、收起
+     */
+    toggleCollapse(collapsed?: boolean): void;
+}