centaline-data-driven-v3 0.1.45 → 0.1.47

package/src/components/web/Tree/Tree.vue

@@ -1,11 +1,12 @@
 <template>
   <div id="ct-tree" class="ct-tree" oncontextmenu="event.preventDefault()" style="overflow:auto;" v-loading="loading"
     :style="{ height: props.treeHeight - 10 + 'px' }">
-    <el-tree class="tree-line" :props="defaultProps" :expand-on-click-node="false" @node-click="handleNodeClick"
+    <el-tree class="tree-line" :props="defaultProps" :expand-on-click-node="false" 
+      @node-click="handleNodeClick"
       :filter-node-method="filterNode" lazy :load="loadNode" ref="refTree" @node-contextmenu="handleContextMenu"
       node-key="code" current-node-key="currentNodeKey" :default-expanded-keys="defaultExpandedKeys">
       <template #default="{ node, data }">
-        <span class="node_content" @mouseenter="handleMouseEnter(data, node)">
+        <span class="node_content" @mouseenter="handleMouseEnter(data, node)" @mousemove="handleMouseMove">
           <el-icon class="node-icon" :class="{ 'is-leaf': node.isLeaf }">
             <Document v-if="node.isLeaf" :size="14" />
             <Folder v-else-if="!node.expanded" :size="14" />
@@ -15,8 +16,9 @@
             {{ data.name }}
           </span>
           <span @click.stop>
-            <el-popover placement="right" :virtual-ref="nodeRef" virtual-triggering :visible="showPopover(data)"
-              :show-after="300" :hide-after="300" :popper-class="allIconsMode ? 'popper-transparent' : ''">
+            <el-popover placement="right" :show-arrow="false" :virtual-ref="nodeRef" virtual-triggering :visible="showPopover(data)" v-if="showPopover(data)" :show-after="0"
+              :hide-after="0" :popper-class="allIconsMode ? 'popper-transparent' : 'popper-menu'"
+              :popper-style="popoverStyle">
               <div class="box-menu" :class="{ 'box-menu-icons': allIconsMode }">
                 <template v-for="(item, index) in allowedRoutes">
                   <template v-if="allIconsMode">
@@ -101,6 +103,11 @@ const hoverNodeCode = ref('')
 const isHoverMode = ref(false) // 是否是悬停模式
 const isManualClose = ref(false) // 是否是手动关闭
 const allIconsMode = ref(false) // 是否全是图标模式
+// 新增：弹出框位置控制
+const popoverStyle = ref({})
+const currentMousePosition = ref({ x: 0, y: 0 }) // 当前鼠标位置
+const lastNodeCode = ref('') // 上次显示菜单的节点code
+const isPositionLockedForCurrentNode = ref(false) // 当前节点的位置是否已锁定
 
 // 默认展开的节点key数组
 const defaultExpandedKeys = ref([])
@@ -116,6 +123,10 @@ const fullTreeData = ref([])
 const nodeCodeMap = ref(new Map())
 
 const isExpandAll = ref(false);
+const isLazyInitialized = ref(false) // 标记是否已经初始化过lazy值
+
+// 新增：记录节点加载状态的Map
+const nodeLoadedStatus = ref(new Map())
 
 /** 动态设置Input Ref */
 const handleSetInputMap = (el: refItem, item) => {
@@ -150,7 +161,6 @@ function showPopover(data) {
 
   const isCurrentNode = data.code === currentData.value.code;
   const hasRoutes = allowedRoutes.value.length > 0;
-
   if (isHoverMode.value) {
     // 悬停模式：当前节点且有路由就显示
     return isCurrentNode && hasRoutes && menuVisible.value;
@@ -162,11 +172,10 @@ function showPopover(data) {
 
 // 鼠标进入节点
 function handleMouseEnter(data, node) {
-  if (isManualClose.value) {
-    isManualClose.value = false;
-    return;
-  }
-
+  // if (isManualClose.value) {
+  //   isManualClose.value = false;
+  //   return;
+  // }
   // 检查当前节点的allowedRoutes是否全是图标
   const routes = getAllowedRoutesForNode(data);
   const allIcons = checkIfAllIcons(routes);
@@ -174,7 +183,7 @@ function handleMouseEnter(data, node) {
   if (allIcons) {
     isHoverMode.value = true;
     hoverNodeCode.value = data.code;
-
+    isManualClose.value = false;
 
     if (hoverNodeCode.value === data.code) {
       showNodeMenu(data, node, true);
@@ -182,12 +191,58 @@ function handleMouseEnter(data, node) {
   }
 }
 
+// 鼠标移动事件
+function handleMouseMove(event) {
+  // 更新鼠标位置
+  currentMousePosition.value = {
+    x: event.clientX,
+    y: event.clientY
+  };
+
+  // 如果是悬停模式且全是图标，并且当前节点的位置尚未锁定，则更新位置
+  if (menuVisible.value && isHoverMode.value && allIconsMode.value && !isPositionLockedForCurrentNode.value) {
+    updatePopoverPosition();
+  }
+}
+
+// 更新弹出框位置（只对当前节点第一次调用时生效）
+function updatePopoverPosition() {
+  // 如果当前节点的位置已锁定，不再更新
+  if (isPositionLockedForCurrentNode.value) {
+    return;
+  }
+
+  // 计算菜单位置，确保不会超出屏幕
+  const screenWidth = window.innerWidth;
+  const menuWidth = allIconsMode.value ? 150 : 200; // 预估菜单宽度
 
+  let left = currentMousePosition.value.x + 15;
+
+  // 检查是否超出右边界
+  if (left + menuWidth > screenWidth) {
+    left = currentMousePosition.value.x - menuWidth - 10;
+  }
+
+  // 只设置水平位置，垂直位置使用 Element UI 默认的
+  popoverStyle.value = {
+    left: `${left}px`
+  };
+
+  // 设置当前节点的位置为已锁定
+  if (currentData.value.code) {
+    isPositionLockedForCurrentNode.value = true;
+  }
+}
 
 // 右键菜单事件
 function handleContextMenu(event, object, node) {
   event.preventDefault();
 
+  // 记录鼠标位置
+  currentMousePosition.value = {
+    x: event.clientX,
+    y: event.clientY
+  };
   // 检查当前节点的allowedRoutes是否全是图标
   const routes = getAllowedRoutesForNode(object);
   const allIcons = checkIfAllIcons(routes);
@@ -196,12 +251,21 @@ function handleContextMenu(event, object, node) {
   if (allIcons) {
     return;
   }
-
+  isManualClose.value = false;
   showNodeMenu(object, node, false);
 }
 
 // 共用方法：显示节点菜单
 function showNodeMenu(object, node, isHoverTrigger = false) {
+  // 检查是否是新的节点
+  const isNewNode = object.code !== lastNodeCode.value;
+
+  if (isNewNode) {
+    // 如果是新节点，重置位置锁定状态
+    isPositionLockedForCurrentNode.value = false;
+    lastNodeCode.value = object.code;
+  }
+
   nodeRef.value = treeNodeRefMap.value[`node_Ref_${object.code}`]
 
   currentData.value = object
@@ -209,19 +273,21 @@ function showNodeMenu(object, node, isHoverTrigger = false) {
 
   allowedRoutes.value = getAllowedRoutesForNode(object);
 
-
-
   if (allowedRoutes.value.length > 0) {
     menuVisible.value = true;
 
-    // if (isHoverTrigger && allIcons) {
-    //   // 悬停模式：自动关闭定时器
-    //   setTimeout(() => {
-    //     if (menuVisible.value && isHoverMode.value) {
-    //       closeMenu();
-    //     }
-    //   }, 300); // 3秒后自动关闭
-    // }
+    // 使用nextTick确保DOM已更新，然后设置位置
+    nextTick(() => {
+      // 如果是右键触发，设置弹出框位置
+      if (!isHoverTrigger && !allIconsMode.value) {
+        updatePopoverPosition();
+      }
+
+      // 如果是悬停模式且全是图标，设置跟随鼠标
+      if (isHoverTrigger && allIconsMode.value) {
+        updatePopoverPosition();
+      }
+    });
 
     // 添加点击事件监听
     document.addEventListener('click', closeMenuOnClick);
@@ -242,10 +308,13 @@ function closeMenu() {
   isManualClose.value = true;
   menuVisible.value = false;
   isHoverMode.value = false;
+  lastNodeCode.value = '';
+  isPositionLockedForCurrentNode.value = false;
 
   hoverNodeCode.value = '';
   nodeRef.value = null;
-  // currentData.value = { ...currentData.value, code: "" };
+  // 重置弹出框样式
+  popoverStyle.value = {};
 
   // 移除事件监听
   document.removeEventListener('click', closeMenuOnClick);
@@ -256,16 +325,19 @@ function closeMenu() {
   }
 }
 
-
-
-
-
 // 设置默认展开节点
 function setDefaultExpandedNodes() {
-  if (!props.expandTwoLevels || !fullTreeData.value.length) {
+  if (!props.expandTwoLevels) {
+    return;
+  }
+
+  // 如果是懒加载模式，使用特定的展开逻辑
+  if (lazy.value) {
+    setLazyModeExpandedNodes();
     return;
   }
 
+  // 全量数据模式
   if (isSearching.value) {
     isExpandAll.value = true;
     const allKeys = Tree.getAllNodeKeys(fullTreeData.value);
@@ -299,9 +371,52 @@ function setDefaultExpandedNodes() {
   hasSetDefaultExpand.value = true;
 }
 
+// 修改：懒加载模式下的展开逻辑
+function setLazyModeExpandedNodes() {
+  if (!fullTreeData.value || fullTreeData.value.length === 0) {
+    return;
+  }
+
+  // 获取所有非叶子节点（最后一层不展开）
+  const nonLeafKeys = [];
+
+  function traverse(nodes) {
+    nodes.forEach(node => {
+      // 关键判断：如果是叶子节点，就不展开
+      const isLeafNode = node.isLeaf === true ||
+        (!node.children || node.children.length === 0);
+
+      if (!isLeafNode) {
+        // 非叶子节点，可以展开
+        nonLeafKeys.push(node.code);
+
+        // 递归处理子节点
+        if (node.children && node.children.length > 0) {
+          traverse(node.children);
+        }
+      }
+    });
+  }
 
+  traverse(fullTreeData.value);
 
+  defaultExpandedKeys.value = nonLeafKeys;
+  hasSetDefaultExpand.value = true;
 
+  // 延迟设置，确保树已渲染
+  nextTick(() => {
+    if (refTree.value && refTree.value.store) {
+      // 只展开已有的非叶子节点，不触发懒加载
+      nonLeafKeys.forEach(key => {
+        const node = refTree.value.getNode(key);
+        if (node && !node.expanded) {
+          // 安全地设置展开状态
+          node.expanded = true;
+        }
+      });
+    }
+  });
+}
 
 // 搜索（查询条件调用）
 function search(m) {
@@ -310,6 +425,8 @@ function search(m) {
   isSearching.value = hasValidSearchConditions;
   screenPara.value = m;
 
+
+
   if (!lazy.value) {
     filterFullTreeData(screenPara.value);
     return;
@@ -334,8 +451,19 @@ function search(m) {
     }, 200);
   }
 }
+function collapseAllNodes() {
+  if (refTree.value && refTree.value.store) {
+    Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
+      if (node) {
+        node.expanded = false;
+      }
+    });
 
-
+    // 清空默认展开的key
+    defaultExpandedKeys.value = [];
+    hasSetDefaultExpand.value = false;
+  }
+}
 // 修改：构建完整的过滤树，保持原始层级结构
 function buildFilteredTreeWithOriginalHierarchy(matchedNodes) {
   if (!matchedNodes || matchedNodes.length === 0) {
@@ -452,7 +580,6 @@ function buildFilteredTreeWithOriginalHierarchy(matchedNodes) {
   return finalRootNodes;
 }
 
-
 // 新增：在全量树中查找父节点code
 function findParentCodeInFullTree(nodeCode) {
   function findParent(nodes, targetCode, parentCode = null) {
@@ -565,9 +692,9 @@ function filterFullTreeData(filter) {
       if (firstNode && firstNode.code) {
         nextTick(() => {
           refTree.value.setCurrentKey(firstNode.code);
-          handleNodeClick(firstNode, true);
+          handleNodeClick(firstNode);
         });
-      } 
+      }
 
     }
 
@@ -590,70 +717,156 @@ function getAllowedRoutesForNode(data) {
 }
 
 // 修改：加载节点，保存节点Map
-function loadNode(node, resolve) {
-  if (!lazy.value) {
-    const nodeData = node.data;
-    resolve(nodeData.children)
+function loadNode(node, resolve) { 
+  // 如果是根节点（level === 0），清空节点加载状态
+  if (node.level === 0) {
+    nodeLoadedStatus.value.clear();
+  }
+  // 如果节点已经加载过，直接返回子节点
+  if (nodeLoadedStatus.value.has(node.key) && nodeLoadedStatus.value.get(node.key) === 'loaded') {
+    if (node.data && node.data.children) {
+      resolve(node.data.children);
+    } else {
+      resolve([]);
+    }
+    return;
+  }
+  
+  // 如果节点已经有数据且不是懒加载模式，直接返回子节点
+  if (node.data && node.data.children && node.data.children.length > 0 && !lazy.value) {
+    resolve(node.data.children);
     return;
   }
 
-  if (node.level === 0) {
+  // 懒加载模式：第一次加载或需要加载子节点
+  if (lazy.value && node.level === 0) {
     loading.value = true;
-    rootNode.value = node
+    rootNode.value = node;
     rootResolve.value = resolve;
-
+     
     return SearchTree(screenPara.value || undefined).then(data => {
       loading.value = false;
+      // 重置前折叠所有节点
+      collapseAllNodes();
+
+      let lazyMode = lazy.value;
+      if (!isLazyInitialized.value) {
+        lazyMode = false;
+      }
 
       const { tree, hasAnyLeaf } = Tree.buildDeptTreeByField(data.rows, {
         pathKey: 'path',
-        separator: '.'
+        separator: '.',
+        lazyMode: lazyMode,
       });
 
-      if (hasAnyLeaf) {
-        fullTreeData.value = tree;
-        nodeCodeMap.value = Tree.buildNodeCodeMap(tree);
-        resolve(tree);
-        if (props.expandTwoLevels) {
-          nextTick(() => {
-            hasSetDefaultExpand.value = false;
-            setDefaultExpandedNodes();
-          });
+      // 只在第一次加载时初始化
+      if (!isLazyInitialized.value) {
+        isLazyInitialized.value = true;
+
+        if (hasAnyLeaf) {
+          lazy.value = !hasAnyLeaf;
+          fullTreeData.value = tree;
+          nodeCodeMap.value = Tree.buildNodeCodeMap(tree);
         }
       }
-      else {
-        resolve(data.rows);
-      }
-      lazy.value = !hasAnyLeaf;
 
+      // 无论是否第一次加载，都解析树数据
+      const resultData = hasAnyLeaf ? tree : data.rows;
+      resolve(resultData);
+      
+      
+
+      if (props.expandTwoLevels && hasAnyLeaf) {
+        fullTreeData.value = tree;
+        nextTick(() => {
+          hasSetDefaultExpand.value = false;
+          setDefaultExpandedNodes();
+        });
+      }
       load(data, true);
+
     }).catch(error => {
       loading.value = false;
       console.error('加载树数据失败:', error);
     });
   }
 
-  if (node.level >= 1 && lazy.value) {
-    let fields = model.value.searchData("code", node.data.code, 9, 3);
-    let filter = {
-      "searchData": {
-        ...(screenPara.value?.searchData || {}),
-        fields: [
-          ...fields.fields,
-          ...(screenPara.value?.searchData?.fields || [])
-        ]
-      }
-    };
+  // 非懒加载模式或懒加载但已有数据
+  if (!lazy.value && node.data && node.data.children) {
+    resolve(node.data.children);
+    return;
+  }
 
-    return SearchTree(filter).then(data => {
-      loading.value = false;
-      resolve(data.rows);
-      load(data, false);
-    }).catch(error => {
-      loading.value = false;
-      console.error('加载子节点失败:', error);
-    });
+  // 懒加载模式加载子节点
+ // 懒加载模式加载子节点
+  if (node.level >= 1 && lazy.value) {
+   
+  // 设置节点为加载中状态
+  if (node && node.key) {
+    nodeLoadedStatus.value.set(node.key, 'loading');
+  }
+  
+  // 检查是否已经有子节点数据
+  if (node.data.children && node.data.children.length > 0) {
+    if (node && node.key) {
+      nodeLoadedStatus.value.set(node.key, 'loaded');
+    }
+    resolve(node.data.children);
+    return;
   }
+
+  let fields = model.value.searchData("code", node.data.code, 9, 3);
+  let filter = {
+    "searchData": {
+      ...(screenPara.value?.searchData || {}),
+      fields: [
+        ...fields.fields,
+        ...(screenPara.value?.searchData?.fields || [])
+      ]
+    }
+  };
+
+  return SearchTree(filter).then(data => {
+    // 标记节点为已加载
+    if (node && node.key) {
+      nodeLoadedStatus.value.set(node.key, 'loaded');
+    }
+    
+    // 关键：更新节点的数据，添加children属性
+    if (node.data) {
+      node.data.children = data.rows;
+      
+      // 判断是否没有子节点
+      if (!data.rows || data.rows.length === 0) {
+        // 没有子节点，设置节点为叶子节点
+        node.data.isLeaf = true;
+        node.isLeaf = true;
+      } else {
+        // 有子节点，设置节点为非叶子节点
+        node.data.isLeaf = false;
+        node.isLeaf = false;
+      }
+    }
+    
+    resolve(data.rows || []);
+    load(data, false);
+  }).catch(error => {
+    loading.value = false;
+    if (node && node.key) {
+      nodeLoadedStatus.value.delete(node.key);
+    }
+    console.error('加载子节点失败:', error);
+    
+    // 加载失败时，如果没有子节点数据，也标记为叶子节点
+    if (node && node.data) {
+      node.data.isLeaf = true;
+      node.isLeaf = true;
+    }
+    
+    resolve([]);
+  });
+}
 }
 
 // 加载数据
@@ -668,13 +881,26 @@ async function load(data, flagRootNode) {
 
   if (flagRootNode) {
     if (model.value.rows && model.value.rows[0]) {
-      handleNodeClick(model.value.rows[0], true);
+      handleNodeClick(model.value.rows[0]);
     }
     nextTick(() => {
       if (model.value.rows && model.value.rows[0] && model.value.rows[0].code) {
         refTree.value.setCurrentKey(model.value.rows[0].code)
       }
     });
+  } else {
+    // 对于子节点加载，检查是否有数据返回
+    const currentNodeCode = currentData.value?.code;
+    if (currentNodeCode) {
+      const treeNode = refTree.value.getNode(currentNodeCode);
+      if (treeNode && (!data.rows || data.rows.length === 0)) {
+        // 没有子节点数据，标记为叶子节点
+        treeNode.isLeaf = true;
+        if (treeNode.data) {
+          treeNode.data.isLeaf = true;
+        }
+      }
+    }
   }
 }
 
@@ -694,6 +920,10 @@ function SearchTree(m) {
 // 重置树到全量数据
 function resetTree() {
   isSearching.value = false;
+
+  // 重置前折叠所有节点
+  collapseAllNodes();
+
   if (fullTreeData.value.length > 0) {
     refTree.value.store.setData(fullTreeData.value);
     hasSetDefaultExpand.value = false;
@@ -701,16 +931,8 @@ function resetTree() {
 
     if (fullTreeData.value[0] && fullTreeData.value[0].code) {
       nextTick(() => {
-        if (refTree.value && refTree.value.store) {
-          Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
-            if (node) {
-              node.expanded = false;
-            }
-          });
-        }
-
         refTree.value.setCurrentKey(fullTreeData.value[0].code);
-        handleNodeClick(fullTreeData.value[0], true);
+        handleNodeClick(fullTreeData.value[0]);
         setDefaultExpandedNodes();
       });
     }
@@ -722,37 +944,78 @@ function clearSearch() {
   screenPara.value = {};
   isSearching.value = false;
 
-  defaultExpandedKeys.value = [];
-  hasSetDefaultExpand.value = false;
+  // 清除前折叠所有节点
+  collapseAllNodes();
 
   if (fullTreeData.value.length > 0) {
     refTree.value.store.setData(fullTreeData.value);
 
     nextTick(() => {
-      if (refTree.value && refTree.value.store) {
-        Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
-          if (node) {
-            node.expanded = false;
-          }
-        });
-      }
-
       setDefaultExpandedNodes();
 
       if (fullTreeData.value[0] && fullTreeData.value[0].code) {
         refTree.value.setCurrentKey(fullTreeData.value[0].code);
-        handleNodeClick(fullTreeData.value[0], true);
+        handleNodeClick(fullTreeData.value[0]);
       }
     });
   }
 }
 
-//节点点击事件
-function handleNodeClick(data, formType) {
+// 修改：节点点击事件，支持自动展开和懒加载
+function handleNodeClick(data) { 
+  
   closeMenu();
-  if (data && formType) {
-    refTree.value.setCurrentKey(data.code)
+  
+  // 设置当前选中节点
+  if (data && data.code) {
+    refTree.value?.setCurrentKey(data.code);
+    
+    // 如果是懒加载模式，检查节点是否需要加载子节点
+    if (lazy.value) {
+      const treeNode = refTree.value.getNode(data.code);
+      if (treeNode) {
+        // 如果节点不是叶子节点但尚未加载，触发加载
+        if (!treeNode.isLeaf && !treeNode.loaded && !treeNode.loading) {
+          loadNode(treeNode, (children) => {
+            if (children && children.length > 0) {
+              // 有子节点，展开节点
+              if (!treeNode.expanded) {
+                treeNode.expanded = true;
+              }
+            } else {
+              // 没有子节点，标记为叶子节点
+              treeNode.isLeaf = true;
+              treeNode.loaded = true;
+              
+              // 更新原始数据中的 isLeaf 属性
+              if (treeNode.data) {
+                treeNode.data.isLeaf = true;
+              }
+              
+              // 如果有父节点，更新父节点的children数组
+              if (treeNode.parent && treeNode.parent.data) {
+                const parentData = treeNode.parent.data;
+                if (parentData.children) {
+                  // 找到当前节点在父节点children中的索引
+                  const index = parentData.children.findIndex(child => child.code === data.code);
+                  if (index !== -1) {
+                    parentData.children[index].isLeaf = true;
+                  }
+                }
+              }
+            }
+          });
+        } else if (treeNode.children && treeNode.children.length > 0 && !treeNode.expanded) {
+          // 如果节点已经有子节点但未展开，展开节点
+          treeNode.expanded = true;
+        } else if (treeNode.loaded && treeNode.children && treeNode.children.length === 0) {
+          // 节点已加载但没有子节点，确保标记为叶子节点
+          treeNode.isLeaf = true;
+        }
+      }
+    }
   }
+  
   if (LastClickNode.value != data) {
     LastClickNode.value = data;
     let rowRouter = model.value.rowSelectRouter;
@@ -776,6 +1039,7 @@ function handleNodeClick(data, formType) {
   }
 }
 
+
 // 菜单路由
 function routerClickHandler(field) {
   isManualClose.value = true;
@@ -811,7 +1075,7 @@ function addNode(newData) {
     // 全量数据模式：手动更新全量数据和树显示
     const parentCode = currentData.value.code;
     const parentPath = currentData.value.path || '';
-    
+
     // 设置新节点的属性
     const newNode = {
       ...newData,
@@ -822,7 +1086,7 @@ function addNode(newData) {
       // 标识是否为叶子节点
       isLeaf: true
     };
-    
+
     // 在全量数据中找到父节点并添加
     const findAndAdd = (nodes, parentCode) => {
       for (let i = 0; i < nodes.length; i++) {
@@ -834,7 +1098,7 @@ function addNode(newData) {
           nodes[i].isLeaf = false; // 父节点不再是叶子节点
           return true;
         }
-        
+
         if (nodes[i].children && nodes[i].children.length > 0) {
           if (findAndAdd(nodes[i].children, parentCode)) {
             return true;
@@ -843,13 +1107,13 @@ function addNode(newData) {
       }
       return false;
     };
-    
+
     // 更新全量数据
     findAndAdd(fullTreeData.value, parentCode);
-    
+
     // 更新nodeCodeMap
     nodeCodeMap.value.set(newNode.code, newNode);
-    
+
     // 如果是搜索状态，需要同时更新当前显示的数据
     if (isSearching.value && screenPara.value) {
       filterFullTreeData(screenPara.value);
@@ -857,7 +1121,7 @@ function addNode(newData) {
       // 非搜索状态，直接重新设置数据
       refTree.value.store.setData([...fullTreeData.value]);
     }
-    
+
     // 刷新树显示
     nextTick(() => {
       // 展开父节点
@@ -866,16 +1130,16 @@ function addNode(newData) {
         refTree.value.store.setCurrentNode(parentNode);
         parentNode.expanded = true;
       }
-      
+
       // 设置新节点为当前选中
-      handleNodeClick(newNode, true);
+      handleNodeClick(newNode);
     });
   } else {
     // 懒加载模式：使用原有方法
     refTree.value.append(newData, currentNode.value);
-    handleNodeClick(newData, true);
+    handleNodeClick(newData);
   }
-} 
+}
 
 //修改树节点
 function updateNode(newData) {
@@ -888,7 +1152,7 @@ function updateNode(newData) {
           nodes[i] = { ...nodes[i], ...newData };
           return true;
         }
-        
+
         if (nodes[i].children && nodes[i].children.length > 0) {
           if (updateInTree(nodes[i].children, nodeCode)) {
             return true;
@@ -897,16 +1161,16 @@ function updateNode(newData) {
       }
       return false;
     };
-    
+
     // 更新全量数据
     updateInTree(fullTreeData.value, currentData.value.code);
-    
+
     // 更新nodeCodeMap
     nodeCodeMap.value.set(currentData.value.code, {
       ...nodeCodeMap.value.get(currentData.value.code),
       ...newData
     });
-    
+
     // 如果是搜索状态，重新过滤显示
     if (isSearching.value && screenPara.value) {
       filterFullTreeData(screenPara.value);
@@ -914,11 +1178,11 @@ function updateNode(newData) {
       // 非搜索状态，直接重新设置数据
       refTree.value.store.setData([...fullTreeData.value]);
     }
-    
+
     // 刷新显示并保持选中状态
     nextTick(() => {
       refTree.value.setCurrentKey(currentData.value.code);
-      handleNodeClick({ ...currentData.value, ...newData }, true);
+      handleNodeClick({ ...currentData.value, ...newData });
     });
   } else {
     // 懒加载模式：使用原有方法
@@ -929,7 +1193,7 @@ function updateNode(newData) {
         currentData.value[key] = newData[key];
       }
     }
-    handleNodeClick(newData, true);
+    handleNodeClick(newData);
   }
 }
 
@@ -939,7 +1203,7 @@ function removeNode(newData) {
     // 全量数据模式：从全量数据中删除
     let parentNode = null;
     let parentCode = null;
-    
+
     const removeFromTree = (nodes, nodeCode) => {
       for (let i = 0; i < nodes.length; i++) {
         if (nodes[i].code === nodeCode) {
@@ -951,13 +1215,13 @@ function removeNode(newData) {
               parentNode = parent;
             }
           }
-          
+
           // 删除节点
           nodes.splice(i, 1);
           nodeCodeMap.value.delete(nodeCode);
           return true;
         }
-        
+
         if (nodes[i].children && nodes[i].children.length > 0) {
           if (removeFromTree(nodes[i].children, nodeCode)) {
             return true;
@@ -966,16 +1230,16 @@ function removeNode(newData) {
       }
       return false;
     };
-    
+
     // 从全量数据中删除
     removeFromTree(fullTreeData.value, currentData.value.code);
-    
+
     // 更新父节点的 isLeaf 状态
     if (parentCode && parentNode) {
       // 重新检查父节点是否还有子节点
       const hasChildren = parentNode.children && parentNode.children.length > 0;
       parentNode.isLeaf = !hasChildren;
-      
+
       // 同步更新 nodeCodeMap
       if (nodeCodeMap.value.has(parentCode)) {
         const updatedParent = nodeCodeMap.value.get(parentCode);
@@ -985,7 +1249,7 @@ function removeNode(newData) {
     } else {
       // 如果是根节点被删除，不需要更新 isLeaf
     }
-    
+
     // 如果是搜索状态，重新过滤显示
     if (isSearching.value && screenPara.value) {
       filterFullTreeData(screenPara.value);
@@ -993,7 +1257,7 @@ function removeNode(newData) {
       // 非搜索状态，直接重新设置数据
       refTree.value.store.setData([...fullTreeData.value]);
     }
-    
+
     // 查找下一个可点击的节点
     getNextClickNode();
   } else {
@@ -1009,7 +1273,7 @@ function findNodeByCode(nodes, targetCode) {
     if (node.code === targetCode) {
       return node;
     }
-    
+
     if (node.children && node.children.length > 0) {
       const found = findNodeByCode(node.children, targetCode);
       if (found) return found;
@@ -1024,7 +1288,7 @@ function findParentNodeInFullTree(nodes, targetCode, parent = null) {
     if (node.code === targetCode) {
       return parent;
     }
-    
+
     if (node.children && node.children.length > 0) {
       const found = findParentNodeInFullTree(node.children, targetCode, node);
       if (found) return found;
@@ -1043,7 +1307,7 @@ function getNextClickNode() {
   } else if (node?.parent) {
     data = node.parent.data;
   }
-  handleNodeClick(data, true)
+  handleNodeClick(data)
 }
 
 /** 过滤节点（全量数据模式下使用） */
@@ -1052,7 +1316,6 @@ function filterNode(value, data) {
   return data.name.toLowerCase().includes(value.toLowerCase())
 }
 
-
 function findSearchFieldValue(searchFields, targetKey, options = {}) {
   const {
     keyFields = ['fieldName1', 'groupName'],
@@ -1137,6 +1400,7 @@ defineExpose({
   display: flex;
   align-items: center;
   position: relative;
+  width: 100%;
 }
 
 .node-icon {
@@ -1153,18 +1417,18 @@ defineExpose({
 
   div {
     cursor: pointer;
+
   }
 }
 
 .box-menu.box-menu-icons {
   display: flex;
   flex-wrap: nowrap;
-  padding: 8px;
+  padding: 8px 0px;
   gap: 0px;
   line-height: 15px;
   background: transparent !important;
-  border: none !important;
-  box-shadow: none !important;
+
 }
 
 .box-menu-icons .opertion {
@@ -1211,6 +1475,8 @@ defineExpose({
   border-radius: 6px;
   position: relative;
   overflow: hidden;
+
+
 }
 
 .box-menu .opertion:hover {
@@ -1250,6 +1516,8 @@ defineExpose({
   display: flex;
   align-items: center;
   width: 100%;
+  justify-content: center; // 垂直居中
+  text-align: center;
 }
 
 /* 菜单激活状态 */
@@ -1267,9 +1535,16 @@ defineExpose({
   background: transparent !important;
   border: none !important;
   box-shadow: none !important;
+  padding: 0 !important;
+
 }
 
-.popper-transparent .el-popper__arrow::before {
-  background: transparent !important;
+// .popper-transparent .el-popper__arrow::before,
+// .popper-menu .el-popper__arrow::before {
+//   background: transparent !important;
+// }
+
+.popper-menu {
+  padding: 0 !important;
 }
 </style>