@ebiz/designer-components 0.0.18-tj.1

package/src/components/charts/framework/module/lineLayout/RectShape/calculate.js

@@ -0,0 +1,174 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+import { percentToDecimal } from '../../../../util/math';
+import { hashString }  from'../../../../util/math';
+
+// 连接点均分模式
+const SHARING_TYPE = {
+    MERGE: 'merge',
+    SHARING:'sharing', 
+    STRICT:'strict'
+};
+
+//根据均分类型计算对应坐标
+function countCoordinate(sideLength,pointData) {
+    let coordinate;
+    let {sharingType, length, index} = pointData;
+    if(sharingType === SHARING_TYPE.SHARING) { // 均分模式
+        coordinate =  sideLength / (length * 2) * ((index-1) * 2 + 1);
+    }
+    else if (sharingType === SHARING_TYPE.STRICT) { // 严格均分模式
+        coordinate =  sideLength / (length + 1) * index;
+    } 
+    else { // 默认模式，不均分连接点位于中间位置
+        coordinate = sideLength / 2;
+    }
+    // 保留一位小数点
+    coordinate = Math.floor(coordinate * 10) / 10
+    return coordinate;
+}
+
+
+// 计算连接点位置
+function calculate(itemData,allConnectorData,option,nodeObj){
+
+    let {startConnector,endConnector} = itemData;
+    if(!nodeObj[itemData.start] || !nodeObj[itemData.end]) return;
+    let startNode = nodeObj[itemData.start];
+    let endNode = nodeObj[itemData.end];
+    let startSharing = option?.connector?.startSharing;
+    let endSharing = option?.connector?.endSharing;
+    countPoint(startConnector,startNode,allConnectorData,startSharing);
+    countPoint(endConnector,endNode,allConnectorData,endSharing);
+    return itemData;
+}
+
+// 计算连接点X，Y坐标
+function countPoint(connector,node,data,sharing) {
+    const {width,height} = node; //
+    const position = connector.position; // 连接点位置
+    const sharingType = sharing; // 连接点分离类型，默认不分离
+    const args = connector.args; // 连接点其他配置信息
+    const length = data[connector.nodeId][position].number; // 同一方向上连接点数量
+    const index = connector.index; // 同一方向上第几个连接点
+    let X,Y; // 连接点的坐标
+    let pointData = {length,index,sharingType};
+    switch (position) {
+        case 'top':
+            X = countCoordinate(width,pointData);
+            Y = 0;
+            break;
+        case 'bottom':
+            X = countCoordinate(width,pointData);
+            Y = height;
+            break;
+        case 'left':
+            X = 0;
+            Y = countCoordinate(height,pointData);
+            break;
+        case 'right':
+            X = width;
+            Y = countCoordinate(height,pointData);
+            break;
+        case 'absolute': 
+            X = args.x.indexOf('%') == -1 ?  width * percentToDecimal(args.x) : args.x;
+            Y = args.y.indexOf('%') == -1 ?  height * percentToDecimal(args.y) : args.y;
+    }
+    let deviateX = 0; // X轴偏移量
+    let deviateY = 0; // Y轴偏移量
+    if(connector.args) { 
+        deviateX = connector.args.dx ? connector.args.dx : 0;
+        deviateY = connector.args.dy ? connector.args.dy : 0;
+    }
+    connector.x = X + deviateX;
+    connector.y = Y + deviateY;
+    connector.id = connector.id || hashString();
+}
+
+//根据均分类型计算对应坐标
+function update(lineData,option) {
+    const type = option?.connector?.sharing;
+    const direction = option.layout?.direction;
+    // 按照相同的起始连接点整理连接数据
+    let lineDataByStart = {};
+    let newLineData = [];
+    // 非默认模式下，将线段数据按相同的起始节点归类
+    if(type === 'sharing' || type === 'strict'){
+        lineData.forEach(item => {
+            let nodeId = item.startNode.id;
+            if(lineDataByStart[nodeId] && lineDataByStart[nodeId].length){
+                lineDataByStart[nodeId].push(item);
+            } else {
+                lineDataByStart[nodeId] = [];
+                lineDataByStart[nodeId].push(item);
+            }
+        });
+
+        Object.keys(lineDataByStart).forEach(key => {
+            let nodeData = lineDataByStart[key];
+            let connectorAllCoordinate = [];
+            // 按照末端节点排序
+            if(direction === 'TB') {
+                nodeData.sort((a, b) => a.endNode.x - b.endNode.x);
+            } else {
+                nodeData.sort((a, b) => a.endNode.y - b.endNode.y);
+            }
+            // 以节点坐标位置，更新连接点坐标，
+            nodeData.forEach(item => {
+                let startConnector = item.startConnector;
+                // 获取一个节点的所有起点连接点坐标
+                connectorAllCoordinate.push({x: startConnector.x,y: startConnector.y});
+                if(connectorAllCoordinate.length === nodeData.length) {
+                    // 按照连接点坐标排序
+                    if(direction === 'TB') {
+                        connectorAllCoordinate.sort((a, b) => a.x - b.x);
+                    } else {
+                        connectorAllCoordinate.sort((a, b) => a.y - b.y);
+                    }
+                    // 更新连接点起始坐标
+                    connectorAllCoordinate.forEach((connector,index) => {
+                        nodeData[index].startConnector.x = connector.x;
+                        nodeData[index].startConnector.y = connector.y;
+                        newLineData.push(nodeData[index]);
+                    })
+                    
+                }
+            })
+            
+        })
+        lineData = newLineData;
+    }
+}
+
+// 相同位置的连接点用同一id
+function someId(edges) {
+    let connectorArr = [];
+    edges.forEach(item => {
+        if(item.startConnector) {
+            connectorArr.push(item.startConnector)
+        }
+        if(item.endConnector) {
+            connectorArr.push(item.endConnector)
+        }
+    })
+    connectorArr.forEach((item,index) => {
+        let remainArr = connectorArr.slice(index + 1);
+        remainArr.forEach(connector => {
+            if(item.x == connector.x && item.y === connector.y && item.nodeId === connector.nodeId) {
+                connector.id = item.id;
+            }
+        })
+    })
+}
+
+    
+export { calculate , update, someId};

package/src/components/charts/framework/module/lineLayout/RectShape/index.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+import init from './init';
+import sharing from './sharing';
+import {calculate, update, someId} from './calculate';
+
+// 矩形节点的连线位置
+class RectShape{
+    constructor(data, option){
+        // 节点对象
+        let nodeObj = {};
+        data.nodes.forEach(item => {
+            nodeObj[item.id] = item;
+        })
+        // 初始连线数据
+        init(data, option, nodeObj);
+        // 获取所有连接点的数量位置信息
+        let connectorData = sharing(data.edges, option);
+        // 开始计算连线位置信息
+        data.edges.forEach(item => {
+            return calculate(item, connectorData, option, nodeObj);
+        });
+        // 如果连接点的位置，则修改为同一id
+        someId(data.edges);
+        // 根据节点位置更新连接点坐标
+        update(data.edges, option);
+    }
+}
+
+export default RectShape;
+
+
+
+

package/src/components/charts/framework/module/lineLayout/RectShape/init.js

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+const VDirection = ['TB', 'BT', 'V'];
+const HDirection = ['LR', 'RL', 'H'];
+const START = 'start';
+const END = 'end';
+const Direction = {
+    'T': 'top',
+    'L': 'left',
+    'R': 'right',
+    'B': 'bottom'
+};
+
+function countPosition(startNode,endNode,direction){
+    let startNodeStartPoint,startNodeEndPoint,endNodeStartPoint,endNodeEndPoint;
+    if(direction === 'H') {
+        startNodeStartPoint = startNode.x;
+        startNodeEndPoint = startNode.x + startNode.width;
+        endNodeStartPoint = endNode.x;
+        endNodeEndPoint = endNode.x + endNode.width;
+    } else {
+        startNodeStartPoint = startNode.y;
+        startNodeEndPoint = startNode.y + startNode.height;
+        endNodeStartPoint = endNode.y;
+        endNodeEndPoint = endNode.y + endNode.height;
+    }
+    // 起始节点左右分别与终止节点左右的距离
+    let distanceArr = [Math.abs(startNodeStartPoint - endNodeStartPoint),Math.abs(startNodeStartPoint - endNodeEndPoint),Math.abs(startNodeEndPoint - endNodeStartPoint),Math.abs(startNodeEndPoint - endNodeEndPoint)];
+    // 获取最小距离
+    let minDistance = Math.min(...distanceArr);
+    let positionArrH = [{start: 'left',end: 'left'},{start: 'left',end: 'right'},{start: 'right',end: 'left'},{start: 'right',end: 'right'}];
+    let positionArrV = [{start: 'top',end: 'top'},{start: 'top',end: 'bottom'},{start: 'bottom',end: 'top'},{start: 'bottom',end: 'bottom'}];
+    let positionArr = direction === 'H' ? positionArrH : positionArrV;
+    return positionArr[distanceArr.indexOf(minDistance)];
+}
+
+function init(data, option, nodeObj){
+    let originalDirection;
+    let direction = originalDirection = option?.layout?.direction || VDirection[0];
+    if(direction === VDirection[2]) direction = VDirection[0];
+    if(direction === HDirection[2]) direction = HDirection[0];
+    let startPosition = Direction[direction[0]];
+    let endPosition = Direction[direction[1]];
+    
+    // let initLineData = [];
+    data.edges.forEach(edge => {
+        if(!edge.start || !edge.end) return;
+        
+        edge.startConnector = edge.startConnector || {
+            port: START,
+            nodeId: edge.start,
+            position: endPosition,
+        };
+        edge.endConnector = edge.endConnector || {
+            port: END,
+            nodeId: edge.end,
+            position: startPosition,
+        };
+        if(originalDirection === 'H' || originalDirection === 'V'){
+            let startNode = nodeObj[edge.start];
+            let endNode = nodeObj[edge.end];
+            let positions = countPosition(startNode,endNode,originalDirection);
+            edge.startConnector.position = positions.start;
+            edge.endConnector.position = positions.end;
+        }
+    });
+}
+
+
+export default init ;

package/src/components/charts/framework/module/lineLayout/RectShape/sharing.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+// 连接点均分模式
+const SHARING_TYPE = {
+    MERGE: 'merge',
+    SHARING:'sharing', 
+    STRICT:'strict'
+};
+
+// 统计节点每个方向的连接点数据
+function statistics(connectorData,item,direction,separate) {
+    const nodeName = direction === 'start' ? 'start' : 'end';
+    const connectorName = direction === 'start' ? 'startConnector' : 'endConnector';
+    // 连接点数据
+    let nodeData = connectorData[item[nodeName]] || {};
+    // 连接点位置
+    let position = item[connectorName].position;
+    // 分离模式下number同一方向连接点数量，index为连接点标识，逐次加1
+    if(nodeData[position]) {
+        nodeData[position].number = separate ? nodeData[position].number + 1: 1;
+        //默认模式下，同一方向有多个连线的，第一个连接点index为1，其他置为-1做标识，代表不用生成连接点dom
+        item[connectorName].index = separate ? nodeData[position].number : -1;
+    } else {
+        nodeData[position] = {number:1};
+        item[connectorName].index = 1; 
+    }
+    return nodeData;
+}
+
+// 获取节点的所有连接点，如果是均分模式或者是严格均分，统计同一方向上的连接点数量，并在原始数据逐次添加连接点数量index标识
+function sharing(data, option) {
+    const connectorData = {}
+    const startSharing = option?.connector?.startSharing; // 连接点模式
+    const endSharing = option?.connector?.startSharing; // 连接点模式
+    const startSeparate = startSharing === SHARING_TYPE.SHARING || startSharing === SHARING_TYPE.STRICT; // 是否为分离模式
+    const endSeparate = endSharing === SHARING_TYPE.SHARING || endSharing === SHARING_TYPE.STRICT;
+    data.forEach(item => {
+        if(item.start && item.startConnector) {
+            connectorData[item.start] = statistics(connectorData,item,'start',startSeparate);
+        }
+        if(item.end && item.endConnector) {
+            connectorData[item.end] = statistics(connectorData,item,'end',endSeparate);
+        }
+    })
+    return connectorData
+
+}
+export default sharing

package/src/components/charts/framework/module/lineLayout/index.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+import RectShape from './RectShape';
+import CircleShape from './CircleShape';
+
+const NodeShape = {
+    rect: RectShape,
+    circle: CircleShape
+}
+
+class LineLayout{
+
+    constructor(data, option){
+        let nodeShape = option.layout?.nodeShape || 'rect';
+        // 根据节点形状，计算连线的开始和结束坐标
+        new NodeShape[nodeShape](data, option);
+
+    }
+}
+
+export default LineLayout;

package/src/components/charts/framework/module/node/Manager.js

@@ -0,0 +1,190 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+import Node from './index';
+import nodeLayout from '../nodeLayout';
+import convertData from './convertData';
+import bufferRender from './bufferRender';
+
+export default class NodeManager {
+    // nodes + edges 数组格式数据, 即 relationData
+    data;
+    // 节点数据
+    nodes;
+    // 节点关系
+    edges;
+    // 布局名称
+    layoutName;
+    // 节点理器工厂
+    instance = {};
+
+    constructor(option, container) {
+        this.option = option;
+        this.container = container;
+        this.canvasContainter = this.container.parentNode;
+    }
+
+    // option.layout.algorithm 为自定义布局算法
+    init(option) {
+        if (option?.layout?.algorithm) {
+            this.layoutName = 'customize';
+        } else {
+            this.layoutName = option?.layout?.type || 'defaults';
+        }
+    }
+
+    // 计算布局
+    layout() {
+        this.init(this.option);
+        let layoutClass = nodeLayout[this.layoutName];
+        let containerRect = this.container.getBoundingClientRect();
+        new layoutClass(this.option.data, containerRect, this.option);
+        // 将 optionData 转成 relationData
+        
+        this.data = convertData[this.layoutName](this.option.data);
+        
+        
+    }
+
+    relayout(option) {
+        this.init(option);
+        let layoutClass = nodeLayout[this.layoutName];
+        let containerRect = this.container.getBoundingClientRect();
+        new layoutClass(option.data, containerRect, option);
+        // 将 optionData 转成 relationData
+        this.data = convertData[this.layoutName](option.data);
+    }
+
+    render() {
+        this.instance = {};
+        let containerRect = this.container.getBoundingClientRect();
+        this.canvasContainterRect = this.canvasContainter.getBoundingClientRect();
+        this.containerCenter = {
+            x: containerRect.width / 2,
+            y: containerRect.height / 2
+        };
+        if (this.option.layout?.bufferRender) {
+            // 执行局部渲染方法
+            console.log("局部渲染")
+            this.data.nodes.forEach(node => {
+                this.bufferRenderNode(node, this.option);
+            });
+        } else {
+            console.log("全局渲染",this.data)
+            // 执行全局渲染方法
+            this.data.nodes.forEach(node => {
+                this.renderNode(node, this.option);
+            });
+
+        }
+
+    }
+
+    // 全局渲染
+    renderNode(node, option) {
+        let nodeInstance = new Node(node, option, this.container);
+        console.log("renderNode",nodeInstance)
+
+        let nodeDom = nodeInstance.render();
+        this.container.appendChild(nodeDom);
+        this.instance[node.id] = nodeInstance;
+    }
+
+    // 局部渲染
+    bufferRenderNode(node, option) {
+        let nodeInstance = new Node(node, option, this.container);
+        // 使用初始偏移 (0, 0) 进行首次渲染
+        bufferRender(nodeInstance, {
+            scale: 1,
+            lastScale: 1,
+            offset: { x: 0, y: 0 },
+            center: this.containerCenter
+        }, this.container, this.canvasContainterRect);// TODO 初始渲染可能缩放值不是1
+        this.instance[node.id] = nodeInstance;
+    }
+
+    // 外部触发局部渲染回调
+    onBufferRender(params) {
+        if (!this.option.layout?.bufferRender) return;
+        for (let id in this.instance) {
+            bufferRender(this.instance[id], params, this.container, this.canvasContainterRect);
+        };
+    };
+
+    // 刷新所有节点，并执行位移动画, this.data为新数据, this.instance为旧数据
+    refresh(option) {
+        let newIds = [];
+        let oldIds = [];
+        this.data.nodes.forEach(newNode => {
+            newIds.push(newNode.id);
+            if (this.isExist(newNode.id)) {
+                this.instance[newNode.id].refresh(newNode);
+            } else {
+                if (option.layout?.bufferRender) {
+                    // 执行局部渲染方法
+                    this.bufferRenderNode(newNode, option);
+                } else {
+                    // 执行全局渲染方法
+                    this.renderNode(newNode, option);
+                }
+            }
+        });
+        oldIds = Object.keys(this.instance);
+        oldIds.forEach(id => {
+            if (newIds.indexOf(id) == -1) {
+                this.unmount(id);
+            }
+        })
+    }
+
+    getNodeData(id) {
+        return this.instance[id]?.getData();
+    }
+
+    getNode(id) {
+        return this.instance[id];
+    }
+
+    // 保存节点的实时位置+大小，用于做动效
+    getCurrentPosition() {
+        let current = {};
+        Object.keys(this.instance).forEach(id => {
+            current[id] = this.instance[id].getCurrentPosition()
+        });
+        return current;
+    }
+
+    getData() {
+        return this.data;// nodes, edges
+    }
+
+    getDom(id){
+        return this.instance[id]?.getDom();
+    }
+
+    isExist(id) {
+        return this.instance[id];
+    }
+
+    update(id, data) {
+        this.instance[id].update(data);
+    }
+
+    // 指定节点添加事件
+    addEventListener(id, eventName, eventCallBack){
+        this.getNode(id).addEventListener(eventName, eventCallBack);
+    }
+
+    unmount(id) {
+        this.instance[id].unmount();
+        delete this.instance[id];
+    }
+}

package/src/components/charts/framework/module/node/bufferRender.js

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+// 局部渲染方法
+function bufferRender(nodeInstance, params, container, canvasContainterRect) {
+  if (nodeInstance.hasRender) return;
+  if (isInBuffer(nodeInstance, params, canvasContainterRect)) {
+    let nodeDom = nodeInstance.render();
+    container.appendChild(nodeDom);
+  };
+};
+
+// 判断节点是否在缓冲区内
+function isInBuffer(node, params, canvasContainterRect) {
+  let { offset, scale, lastScale, center, type } = params;
+  // TODO 之后可以放到option里面
+  const buffer = 1.3; // 缓冲区是容器大小的1.5倍 
+  // 缓冲区的长宽
+  const bufferWidth = canvasContainterRect.width * buffer;
+  const bufferHeight = canvasContainterRect.height * buffer;
+
+  // 缓冲区的边界
+  const bufferLeft = (canvasContainterRect.width - bufferWidth) / 2;
+  const bufferTop = (canvasContainterRect.height - bufferHeight) / 2;
+  const bufferRight = bufferLeft + bufferWidth;
+  const bufferBottom = bufferTop + bufferHeight;
+
+  let { x, y, width, height, nodeRealY, nodeRealX } = node.data;
+
+  if (type === 'move') lastScale = scale;
+
+  // 计算节点相当于上一个节点的偏移量
+  let nodeOffset = {
+    x: offset.x + ((nodeRealX || x) - center.x) / lastScale * (scale - lastScale),
+    y: offset.y + ((nodeRealY || y) - center.y) / lastScale * (scale - lastScale),
+  };
+
+  nodeRealX = (nodeRealX || x) + nodeOffset.x;
+  nodeRealY = (nodeRealY || y) + nodeOffset.y;
+
+  // 存储节点坐标 方便下次使用
+  node.data.nodeRealX = nodeRealX;
+  node.data.nodeRealY = nodeRealY;
+
+  // 计算节点的四个角的坐标（基于当前偏移和缩放）
+  const topLeftX = nodeRealX;
+  const topLeftY = nodeRealY;
+  const topRightX = nodeRealX + width * scale;
+  const topRightY = nodeRealY;
+  const bottomLeftX = nodeRealX;
+  const bottomLeftY = nodeRealY + height * scale;
+  const bottomRightX = nodeRealX + width * scale;
+  const bottomRightY = nodeRealY + height * scale;
+
+  // 检查四个角是不是都在缓冲区
+  const allCornersOutside = (
+    (topLeftX < bufferLeft || topLeftX > bufferRight || topLeftY < bufferTop || topLeftY > bufferBottom) &&
+    (topRightX < bufferLeft || topRightX > bufferRight || topRightY < bufferTop || topRightY > bufferBottom) &&
+    (bottomLeftX < bufferLeft || bottomLeftX > bufferRight || bottomLeftY < bufferTop || bottomLeftY > bufferBottom) &&
+    (bottomRightX < bufferLeft || bottomRightX > bufferRight || bottomRightY < bufferTop || bottomRightY > bufferBottom)
+  );
+  return !allCornersOutside;
+}
+
+export default bufferRender;

package/src/components/charts/framework/module/node/convertData/index.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+import treeToLink from './treeToLink';
+import returnSelf from './returnSelf';
+import transform from './transform';
+
+// 将不同算法的输入数据格式转换成nodes + edges格式
+export default {
+    'grid': returnSelf,
+    'circle': returnSelf,
+    'linearArc': returnSelf,
+    'customize': returnSelf,
+    'mindmap': treeToLink,
+    'defaults': transform
+}

package/src/components/charts/framework/module/node/convertData/returnSelf.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2024 - present OpenTiny HUICharts Authors.
+ * Copyright (c) 2024 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+function returnSelf(data){
+    return data;
+}
+
+export default returnSelf;