strategy-panel 1.0.1 → 1.0.2

package/lib/packages/graph-canvas/node-types.d.ts

@@ -0,0 +1,6 @@
+export declare const SCENE_DISPLAY: any;
+export declare const COMPONENTS_TYPE: any;
+export declare const COMMONLY_USED: any;
+export declare const SIGN_OPERATION: any;
+export declare const MOTION_OPERATION: any;
+export declare const PanelType: any;

package/lib/packages/graph-canvas/node-types.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SIGN_OPERATION = exports.SCENE_DISPLAY = exports.PanelType = exports.MOTION_OPERATION = exports.COMPONENTS_TYPE = exports.COMMONLY_USED = void 0;
+var SCENE_DISPLAY = {
+  EQUIPMENT: 'SCENE_DISPLAY_EQUIPMENT',
+  // 设备触发
+  TIME: 'SCENE_DISPLAY_TIME',
+  // 时间触发
+  MANUAL: 'SCENE_DISPLAY_MANUAL' // 手动触发
+
+}; // 场景触发
+
+exports.SCENE_DISPLAY = SCENE_DISPLAY;
+var COMPONENTS_TYPE = {
+  COMMONLY_USED: 'COMMONLY_USED',
+  // 通用组件
+  SCENE_DISPLAY: 'SCENE_DISPLAY',
+  // 场景触发
+  SIGN_OPERATION: 'SIGN_OPERATION',
+  // 运算符号
+  MOTION_OPERATION: 'MOTION_OPERATION',
+  // 运动符号
+  APPLICATION: 'APPLICATION' // 应用组件
+
+};
+exports.COMPONENTS_TYPE = COMPONENTS_TYPE;
+var COMMONLY_USED = {
+  VARIATE: 'COMMONLY_USED_VARIATE',
+  // 变量
+  LOCKED: 'COMMONLY_USED_SERVICE_LOCKING'
+}; // 通用组件
+
+exports.COMMONLY_USED = COMMONLY_USED;
+var SIGN_OPERATION = {
+  RELATION: 'SIGN_OPERATION_RELATION',
+  // 关系运算
+  LOGICAL: 'SIGN_OPERATION_LOGICAL',
+  // 逻辑运算
+  CONDITION: 'SIGN_OPERATION_CONDITION' // 条件判断
+
+}; // 运算符号
+
+exports.SIGN_OPERATION = SIGN_OPERATION;
+var MOTION_OPERATION = {
+  ALARM: 'MOTION_OPERATION_ALARM',
+  // 报警
+  NOTICE: 'MOTION_OPERATION_NOTICE',
+  // 通知
+  ORDER: 'MOTION_OPERATION_ORDER',
+  // 派发工单
+  CONTROL: 'MOTION_OPERATION_CONTROL' // 远程控制
+
+}; // 运动符号
+
+exports.MOTION_OPERATION = MOTION_OPERATION;
+var PanelType = {
+  COMMONLY_USED: COMMONLY_USED,
+  SCENE_DISPLAY: SCENE_DISPLAY,
+  SIGN_OPERATION: SIGN_OPERATION,
+  MOTION_OPERATION: MOTION_OPERATION,
+  COMPONENTS_TYPE: COMPONENTS_TYPE
+};
+exports.PanelType = PanelType;

package/lib/packages/graph-canvas/typings.d.ts

@@ -0,0 +1,5 @@
+export type ModeType = 'platform' | 'view';
+
+export interface PanelComponentProps {
+  mode?: ModeType;
+}

package/lib/packages/graph-common/global.d.ts

@@ -0,0 +1 @@
+export declare const ANT_PREFIX = "ant";

package/lib/packages/graph-common/global.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ANT_PREFIX = void 0;
+var ANT_PREFIX = 'ant';
+exports.ANT_PREFIX = ANT_PREFIX;

package/lib/packages/graph-common/graph.d.ts

@@ -0,0 +1,12 @@
+export declare const GROUP_HORIZONTAL__PADDING = 24;
+export declare const GROUP_VERTICAL__PADDING = 40;
+export declare const NODE_WIDTH = 180;
+export declare const NODE_HEIGHT = 43;
+export declare const APPLICATION_NODE_WIDTH = 400;
+export declare const APPLICATION_NODE_HEIGHT = 300;
+export declare const LOGICAL_EDG = 50;
+export declare const CONDITION_WIDTH = 260;
+export declare const CONDITION_HEIGHT = 107;
+export declare const RERENDER_EVENT = "RERENDER_EVENT";
+export declare const DRAGGABLE_ALGO_COMPONENT = "ALGO_COMPONENT";
+export declare const DRAGGABLE_MODEL = "MODEL";

package/lib/packages/graph-common/graph.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RERENDER_EVENT = exports.NODE_WIDTH = exports.NODE_HEIGHT = exports.LOGICAL_EDG = exports.GROUP_VERTICAL__PADDING = exports.GROUP_HORIZONTAL__PADDING = exports.DRAGGABLE_MODEL = exports.DRAGGABLE_ALGO_COMPONENT = exports.CONDITION_WIDTH = exports.CONDITION_HEIGHT = exports.APPLICATION_NODE_WIDTH = exports.APPLICATION_NODE_HEIGHT = void 0;
+var GROUP_HORIZONTAL__PADDING = 24; // 分组横向 padding
+
+exports.GROUP_HORIZONTAL__PADDING = GROUP_HORIZONTAL__PADDING;
+var GROUP_VERTICAL__PADDING = 40; // 分组纵向 padding
+
+exports.GROUP_VERTICAL__PADDING = GROUP_VERTICAL__PADDING;
+var NODE_WIDTH = 180;
+exports.NODE_WIDTH = NODE_WIDTH;
+var NODE_HEIGHT = 43;
+exports.NODE_HEIGHT = NODE_HEIGHT;
+var APPLICATION_NODE_WIDTH = 400;
+exports.APPLICATION_NODE_WIDTH = APPLICATION_NODE_WIDTH;
+var APPLICATION_NODE_HEIGHT = 300;
+exports.APPLICATION_NODE_HEIGHT = APPLICATION_NODE_HEIGHT;
+var LOGICAL_EDG = 50;
+exports.LOGICAL_EDG = LOGICAL_EDG;
+var CONDITION_WIDTH = 260;
+exports.CONDITION_WIDTH = CONDITION_WIDTH;
+var CONDITION_HEIGHT = 107; // 触发画布重新渲染事件
+
+exports.CONDITION_HEIGHT = CONDITION_HEIGHT;
+var RERENDER_EVENT = 'RERENDER_EVENT';
+/*
+ * 以下是拖拽相关
+ */
+
+exports.RERENDER_EVENT = RERENDER_EVENT;
+var DRAGGABLE_ALGO_COMPONENT = 'ALGO_COMPONENT';
+exports.DRAGGABLE_ALGO_COMPONENT = DRAGGABLE_ALGO_COMPONENT;
+var DRAGGABLE_MODEL = 'MODEL';
+exports.DRAGGABLE_MODEL = DRAGGABLE_MODEL;

package/lib/packages/graph-core/graph-util.d.ts

@@ -0,0 +1,182 @@
+import type { NExperimentGraph } from './typing';
+import type BaseNode from '../graph-model/node';
+import '../graph-model/connector';
+export declare function expandGroupAccordingToNodes(params: {
+    moveNodes: BaseNode[];
+}): void;
+export declare function formatNodeInfoToNodeMeta(nodeData: NExperimentGraph.Node, inputPortConnectedMap?: {
+    [k: string]: boolean;
+}): {
+    x: number;
+    y: number;
+    type: string;
+    id: string;
+    data: {
+        type: string;
+        x: number;
+        y: number;
+        id: string;
+        outPorts: NExperimentGraph.Port[];
+        inPorts: NExperimentGraph.Port[];
+        positionX: number;
+        positionY: number;
+        codeName?: string | undefined;
+        category?: string | undefined;
+        name: string;
+        nodeInstanceId?: number | undefined;
+        groupId?: number | undefined;
+        status?: number | undefined;
+    };
+    ports: {
+        items: any[];
+    };
+    zIndex: number;
+    outPorts: NExperimentGraph.Port[];
+    inPorts: NExperimentGraph.Port[];
+    positionX: number;
+    positionY: number;
+    codeName?: string | undefined;
+    category?: string | undefined;
+    name: string;
+    nodeInstanceId?: number | undefined;
+    groupId?: number | undefined;
+    status?: number | undefined;
+};
+export declare function calcNodeScale(groupData: NExperimentGraph.Group, children: any[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function formatGroupInfoToNodeMeta(groupData: NExperimentGraph.Group, nodeData: any[], edges?: any[]): {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+    data: {
+        type: string;
+        includedNodes: any[];
+        id: string;
+        isCollapsed: boolean;
+        experimentId: number;
+        name: string;
+    };
+    ports: {
+        items: {
+            group: string;
+            id: string;
+            connected: boolean;
+        }[];
+    };
+    isCollapsed: boolean;
+    experimentId: number;
+    name: string;
+    type: string;
+} | {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+    data: {
+        type: string;
+        includedNodes: any[];
+        id: string;
+        isCollapsed: boolean;
+        experimentId: number;
+        name: string;
+    };
+    isCollapsed: boolean;
+    experimentId: number;
+    name: string;
+    type: string;
+};
+export declare function formatGraphData(graphData?: NExperimentGraph.ExperimentGraph): {
+    nodes: ({
+        x: number;
+        y: number;
+        type: string;
+        id: string;
+        data: {
+            type: string;
+            x: number;
+            y: number;
+            id: string;
+            outPorts: NExperimentGraph.Port[];
+            inPorts: NExperimentGraph.Port[];
+            positionX: number;
+            positionY: number;
+            codeName?: string | undefined;
+            category?: string | undefined;
+            name: string;
+            nodeInstanceId?: number | undefined;
+            groupId?: number | undefined;
+            status?: number | undefined;
+        };
+        ports: {
+            items: any[];
+        };
+        zIndex: number;
+        outPorts: NExperimentGraph.Port[];
+        inPorts: NExperimentGraph.Port[];
+        positionX: number;
+        positionY: number;
+        codeName?: string | undefined;
+        category?: string | undefined;
+        name: string;
+        nodeInstanceId?: number | undefined;
+        groupId?: number | undefined;
+        status?: number | undefined;
+    } | {
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zIndex: number;
+        data: {
+            type: string;
+            includedNodes: any[];
+            id: string;
+            isCollapsed: boolean;
+            experimentId: number;
+            name: string;
+        };
+        isCollapsed: boolean;
+        experimentId: number;
+        name: string;
+        type: string;
+    })[];
+    edges: {
+        data: {
+            inputPortId: number;
+            outputPortId: number;
+            source: number;
+            type?: string | undefined;
+            target: number;
+        };
+        sourceAnchor: string;
+        source: {
+            cell: string;
+            port: string;
+            anchor: {
+                name: string;
+            };
+        };
+        target: {
+            cell: string;
+            port: string;
+            anchor: {
+                name: string;
+            };
+        };
+        label: string;
+        zIndex: number;
+        inputPortId: number;
+        outputPortId: number;
+        type?: string | undefined;
+    }[];
+};

package/lib/packages/graph-core/graph-util.js

@@ -0,0 +1,368 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcNodeScale = calcNodeScale;
+exports.expandGroupAccordingToNodes = expandGroupAccordingToNodes;
+exports.formatGraphData = formatGraphData;
+exports.formatGroupInfoToNodeMeta = formatGroupInfoToNodeMeta;
+exports.formatNodeInfoToNodeMeta = formatNodeInfoToNodeMeta;
+
+var _lodashEs = require("lodash-es");
+
+var _graph = require("../graph-common/graph");
+
+require("../graph-model/connector");
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// group 范围适应内部节点变化
+function expandGroupAccordingToNodes(params) {
+  var moveNodes = params.moveNodes;
+  var parentNodes = [];
+  moveNodes.forEach(function (node) {
+    var parentNode = node.getParent();
+
+    if (parentNode && !parentNodes.includes(parentNode)) {
+      parentNodes.push(parentNode);
+    }
+  });
+  parentNodes.forEach(function (parent) {
+    var originSize = parent.getSize();
+    var originPosition = parent.getPosition();
+    var originX = originPosition.x;
+    var originY = originPosition.y;
+    var originWidth = originSize.width;
+    var originHeight = originSize.height;
+    var children = parent.getChildren();
+    var childNodes = children.filter(function (child) {
+      return child.isNode();
+    });
+
+    if (childNodes !== null && childNodes !== void 0 && childNodes.length) {
+      var _minBy, _minBy2, _maxBy, _maxBy2;
+
+      var positions = childNodes.map(function (childNode) {
+        return childNode.getPosition();
+      });
+      var minX = ((_minBy = (0, _lodashEs.minBy)(positions, 'x')) === null || _minBy === void 0 ? void 0 : _minBy.x) || 0;
+      var minY = ((_minBy2 = (0, _lodashEs.minBy)(positions, 'y')) === null || _minBy2 === void 0 ? void 0 : _minBy2.y) || 0;
+      var maxX = ((_maxBy = (0, _lodashEs.maxBy)(positions, 'x')) === null || _maxBy === void 0 ? void 0 : _maxBy.x) || 0;
+      var maxY = ((_maxBy2 = (0, _lodashEs.maxBy)(positions, 'y')) === null || _maxBy2 === void 0 ? void 0 : _maxBy2.y) || 0;
+      var nextX = minX - _graph.GROUP_HORIZONTAL__PADDING;
+      var nextY = minY - _graph.GROUP_VERTICAL__PADDING;
+      var nextWidth = maxX - minX + 2 * _graph.GROUP_HORIZONTAL__PADDING + _graph.NODE_WIDTH;
+      var nextHeight = maxY - minY + 2 * _graph.GROUP_VERTICAL__PADDING + _graph.NODE_HEIGHT;
+
+      if (originX !== nextX || originY !== nextY || originWidth !== nextWidth || originHeight !== nextHeight) {
+        parent.prop({
+          position: {
+            x: nextX,
+            y: nextY
+          },
+          size: {
+            width: nextWidth,
+            height: nextHeight
+          }
+        });
+      }
+    }
+  });
+} // 格式化单个节点，新增节点时复用
+
+
+function formatNodeInfoToNodeMeta(nodeData) {
+  var inputPortConnectedMap = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  console.log('formatNodeInfoToNodeMeta', nodeData);
+  var portItems = [];
+  var id = nodeData.id,
+      nodeInstanceId = nodeData.nodeInstanceId,
+      positionX = nodeData.positionX,
+      positionY = nodeData.positionY,
+      inPorts = nodeData.inPorts,
+      outPorts = nodeData.outPorts;
+  (0, _lodashEs.sortBy)(inPorts, 'sequence').forEach(function (inPort) {
+    portItems.push(_objectSpread(_objectSpread({}, inPort), {}, {
+      group: 'in',
+      id: inPort.id.toString(),
+      connected: inputPortConnectedMap[inPort.id.toString()]
+    }));
+  });
+  (0, _lodashEs.sortBy)(outPorts, 'sequence').forEach(function (outPort) {
+    portItems.push(_objectSpread(_objectSpread({}, outPort), {}, {
+      group: (outPort === null || outPort === void 0 ? void 0 : outPort.group) || 'out',
+      id: outPort.id.toString(),
+      connected: inputPortConnectedMap[outPort.id.toString()]
+    }));
+  });
+  var x = positionX || 0;
+  var y = positionY || 0;
+  return _objectSpread(_objectSpread({}, nodeData), {}, {
+    x: x,
+    y: y,
+    type: 'node',
+    id: (nodeInstanceId || id).toString(),
+    data: _objectSpread(_objectSpread({}, nodeData), {}, {
+      type: 'node',
+      x: x,
+      y: y,
+      id: (nodeInstanceId || id).toString()
+    }),
+    ports: {
+      items: portItems
+    },
+    zIndex: 10
+  });
+} // 根据群组节点的收缩状态及子节点，计算出节点群组的尺寸和位置
+
+
+function calcNodeScale(groupData, children) {
+  var _minBy3, _minBy4, _maxBy3, _maxBy4;
+
+  var _groupData$isCollapse = groupData.isCollapsed,
+      isCollapsed = _groupData$isCollapse === void 0 ? false : _groupData$isCollapse;
+  var minX = (_minBy3 = (0, _lodashEs.minBy)(children, 'x')) === null || _minBy3 === void 0 ? void 0 : _minBy3.x;
+  var minY = (_minBy4 = (0, _lodashEs.minBy)(children, 'y')) === null || _minBy4 === void 0 ? void 0 : _minBy4.y;
+  var maxX = (_maxBy3 = (0, _lodashEs.maxBy)(children, 'x')) === null || _maxBy3 === void 0 ? void 0 : _maxBy3.x;
+  var maxY = (_maxBy4 = (0, _lodashEs.maxBy)(children, 'y')) === null || _maxBy4 === void 0 ? void 0 : _maxBy4.y;
+  var defaultX = minX - _graph.GROUP_HORIZONTAL__PADDING;
+  var defaultY = minY - _graph.GROUP_VERTICAL__PADDING;
+  var defaultWidth = maxX - minX + 2 * _graph.GROUP_HORIZONTAL__PADDING + _graph.NODE_WIDTH;
+
+  if (isCollapsed) {
+    return {
+      x: defaultX + defaultWidth / 2 - _graph.NODE_WIDTH / 2,
+      y: defaultY,
+      width: _graph.NODE_WIDTH,
+      height: _graph.NODE_HEIGHT
+    };
+  }
+
+  return {
+    x: defaultX,
+    y: defaultY,
+    width: defaultWidth,
+    height: maxY - minY + 2 * _graph.GROUP_VERTICAL__PADDING + _graph.NODE_HEIGHT
+  };
+} // 格式化单个群组，新增群组时复用
+
+
+function formatGroupInfoToNodeMeta(groupData, nodeData, edges) {
+  var id = groupData.id,
+      _groupData$isCollapse2 = groupData.isCollapsed,
+      isCollapsed = _groupData$isCollapse2 === void 0 ? false : _groupData$isCollapse2;
+  var includedNodes = nodeData.filter(function (nodeMeta) {
+    return nodeMeta.groupId.toString() === id.toString();
+  });
+
+  var _calcNodeScale = calcNodeScale(groupData, includedNodes),
+      x = _calcNodeScale.x,
+      y = _calcNodeScale.y,
+      width = _calcNodeScale.width,
+      height = _calcNodeScale.height; // group 已收缩则必定已存在，而不是处理新增的 group，因此处理的 nodeData 是 meta 数据而不是 getData 的数据
+
+
+  if (isCollapsed && edges) {
+    // eslint-disable-next-line no-param-reassign
+    includedNodes.forEach(function (node) {
+      node.data.hide = true;
+    });
+    var includedNodeIds = includedNodes.map(function (nodeDataItem) {
+      return nodeDataItem.id.toString();
+    }); // 从外部进入到 group 内部的连线
+
+    var edgesFromOutside = edges.filter(function (edge) {
+      var source = edge.source,
+          target = edge.target;
+      return includedNodeIds.includes(target.cell.toString()) && !includedNodeIds.includes(source.cell.toString());
+    }); // 从 group 穿到外部的连线
+
+    var edgesToOutside = edges.filter(function (edge) {
+      var source = edge.source,
+          target = edge.target;
+      return includedNodeIds.includes(source.cell.toString()) && !includedNodeIds.includes(target.cell.toString());
+    });
+    var portItems = [];
+
+    if (edgesFromOutside !== null && edgesFromOutside !== void 0 && edgesFromOutside.length) {
+      var portId = Date.now().toString();
+      portItems.push({
+        group: 'in',
+        id: portId,
+        connected: true
+      }); // 增加 group 的输入桩
+      // 增加连接到 group 输入桩的连线
+
+      edgesFromOutside.forEach(function (edge) {
+        var source = edge.source,
+            outputPortId = edge.outputPortId;
+        edges.push({
+          sourceAnchor: 'bottom',
+          source: {
+            cell: source.cell.toString(),
+            port: outputPortId.toString(),
+            anchor: {
+              name: 'bottom'
+            }
+          },
+          target: {
+            cell: id.toString(),
+            port: portId,
+            anchor: {
+              name: 'center'
+            }
+          },
+          label: '',
+          zIndex: 1
+        });
+      });
+    }
+
+    if (edgesToOutside !== null && edgesToOutside !== void 0 && edgesToOutside.length) {
+      var _portId = (Date.now() + 1).toString();
+
+      portItems.push({
+        group: 'out',
+        id: _portId,
+        connected: false
+      }); // 增加 group 的输出桩
+      // 增加链接到 group 输出桩的连线
+
+      edgesToOutside.forEach(function (edge) {
+        var target = edge.target,
+            inputPortId = edge.inputPortId;
+        edges.push({
+          type: 'group',
+          sourceAnchor: 'bottom',
+          source: {
+            cell: id,
+            port: _portId,
+            anchor: {
+              name: 'bottom'
+            }
+          },
+          target: {
+            cell: target.cell,
+            port: inputPortId,
+            anchor: {
+              name: 'center'
+            }
+          },
+          label: '',
+          zIndex: 1
+        });
+      });
+    }
+
+    return _objectSpread(_objectSpread({
+      type: 'group'
+    }, groupData), {}, {
+      id: id.toString(),
+      x: x,
+      y: y,
+      width: width,
+      height: height,
+      zIndex: 1,
+      data: _objectSpread(_objectSpread({}, groupData), {}, {
+        type: 'group',
+        includedNodes: includedNodes,
+        id: id.toString()
+      }),
+      ports: {
+        items: portItems
+      }
+    });
+  }
+
+  return _objectSpread(_objectSpread({
+    type: 'group'
+  }, groupData), {}, {
+    id: id.toString(),
+    x: x,
+    y: y,
+    width: width,
+    height: height,
+    zIndex: 1,
+    data: _objectSpread(_objectSpread({}, groupData), {}, {
+      type: 'group',
+      includedNodes: includedNodes,
+      id: id.toString()
+    })
+  });
+} // 将接口返回的图信息转换为图渲染引擎可渲染的信息
+
+
+function formatGraphData() {
+  var graphData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _graphData$nodes = graphData.nodes,
+      nodes = _graphData$nodes === void 0 ? [] : _graphData$nodes,
+      _graphData$links = graphData.links,
+      links = _graphData$links === void 0 ? [] : _graphData$links,
+      _graphData$groups = graphData.groups,
+      groups = _graphData$groups === void 0 ? [] : _graphData$groups; // 格式化边
+
+  var formattedEdges = links.map(function (link) {
+    var source = link.source,
+        outputPortId = link.outputPortId,
+        target = link.target,
+        inputPortId = link.inputPortId;
+    return _objectSpread(_objectSpread({}, link), {}, {
+      data: _objectSpread({}, link),
+      sourceAnchor: 'bottom',
+      source: {
+        cell: source.toString(),
+        port: outputPortId.toString(),
+        anchor: {
+          name: 'bottom'
+        }
+      },
+      target: {
+        cell: target.toString(),
+        port: inputPortId.toString(),
+        anchor: {
+          name: 'center'
+        }
+      },
+      label: '',
+      zIndex: 1
+    });
+  }); // 记录所有已连线的输入桩
+
+  var inputPortConnectedMap = formattedEdges.reduce(function (acc, edge) {
+    acc[edge.inputPortId] = true;
+    return acc;
+  }, {}); // 格式化算法组件节点
+
+  var formattedNodes = nodes.map(function (nodeData) {
+    return formatNodeInfoToNodeMeta(nodeData, inputPortConnectedMap);
+  }); // 格式化群组节点
+
+  var formattedGroups = groups.map(function (groupData) {
+    return formatGroupInfoToNodeMeta(groupData, formattedNodes, formattedEdges);
+  });
+  return {
+    nodes: [].concat(_toConsumableArray(formattedNodes), _toConsumableArray(formattedGroups.filter(function (group) {
+      var _group$data, _group$data$includedN;
+
+      return !!(group !== null && group !== void 0 && (_group$data = group.data) !== null && _group$data !== void 0 && (_group$data$includedN = _group$data.includedNodes) !== null && _group$data$includedN !== void 0 && _group$data$includedN.length);
+    }))),
+    edges: formattedEdges
+  };
+}