@hsu-react/ui 0.0.13 → 0.0.15

package/es/components/Tree/_hooks/useTreeCheck.js

@@ -1,15 +1,15 @@
 import { useCallback } from "react";
 /**
- * 处理树勾选的 hook
- * 使用 antd 默认逻辑，不做额外操作
+ * Hook for handling tree checking
+ * Uses antd's default logic without any extra operations
  */
 export var useTreeCheck = function useTreeCheck(setCheckedKeys, onCheck, onChange) {
-  // 处理勾选逻辑：直接使用 antd 的默认行为
+  // Handle check logic: directly use antd's default behavior
   var handleCheck = useCallback(function (checked, info) {
     setCheckedKeys(checked);
     onCheck === null || onCheck === void 0 || onCheck(checked, info);
 
-    // 触发 onChange 回调
+    // Trigger the onChange callback
     if (onChange) {
       if (Array.isArray(checked)) {
         onChange({

package/es/components/Tree/_hooks/useTreeSearch.d.ts

@@ -1,7 +1,7 @@
 import { Key } from "react";
 import { TreeData } from "..";
 /**
- * 处理树搜索的 hook
+ * Hook for handling tree search
  */
 export declare const useTreeSearch: (treeData: TreeData[], setExpandedKeys: React.Dispatch<React.SetStateAction<Key[] | undefined>>) => {
     searchKey: string;

package/es/components/Tree/_hooks/useTreeSearch.js

@@ -9,7 +9,7 @@ import { useCallback, useMemo, useEffect, useState, useRef } from "react";
 import { filterTreeData } from "../_utils";
 
 /**
- * 处理树搜索的 hook
+ * Hook for handling tree search
  */
 export var useTreeSearch = function useTreeSearch(treeData, setExpandedKeys) {
   var _useState = useState(""),
@@ -18,8 +18,8 @@ export var useTreeSearch = function useTreeSearch(treeData, setExpandedKeys) {
     setSearchKey = _useState2[1];
   var prevSearchKeyRef = useRef("");
 
-  // 处理树数据（搜索过滤）
-  // filterTreeData 内部已经处理了数据拷贝，无需额外 cloneDeep
+  // Process tree data (search filtering)
+  // filterTreeData already handles data copying internally, no extra cloneDeep needed
   var filteredTreeData = useMemo(function () {
     if (!searchKey.trim()) {
       return treeData;
@@ -27,24 +27,24 @@ export var useTreeSearch = function useTreeSearch(treeData, setExpandedKeys) {
     return filterTreeData(searchKey, treeData);
   }, [searchKey, treeData]);
 
-  // 处理搜索时的展开逻辑
+  // Handle expand logic while searching
   useEffect(function () {
     var trimmedSearchKey = searchKey.trim();
     var prevTrimmedKey = prevSearchKeyRef.current.trim();
 
-    // 如果搜索关键词没有变化，跳过处理
+    // Skip processing if the search keyword has not changed
     if (trimmedSearchKey === prevTrimmedKey) {
       return;
     }
     prevSearchKeyRef.current = searchKey;
 
-    // 清空搜索时，重置展开状态
+    // When the search is cleared, reset the expanded state
     if (!trimmedSearchKey) {
       setExpandedKeys([]);
       return;
     }
 
-    // 有搜索关键词时，展开所有匹配的节点
+    // When there is a search keyword, expand all matching nodes
     if (!filteredTreeData.length) {
       return;
     }

package/es/components/Tree/_hooks/useTreeState.d.ts

@@ -1,11 +1,11 @@
 import { Key } from "react";
 import { CheckedKeys, TreeData } from "..";
 /**
- * 同步外部 expandedKeys 的 hook
+ * Hook for syncing external expandedKeys
  */
 export declare const useExpandedKeys: (expandedKeysProps?: Key[], defaultExpandedKeys?: Key[]) => readonly [Key[] | undefined, (keys: Key[] | ((prev: Key[] | undefined) => Key[] | undefined) | undefined) => void];
 /**
- * 同步外部 checkedKeys 的 hook
- * 自动规范化：当父级在 checked 中但子项未全选时，将父级设为半选
+ * Hook for syncing external checkedKeys
+ * Auto-normalizes: when a parent is in checked but its children are not all checked, the parent is set to half-checked
  */
 export declare const useCheckedKeys: (checkedKeysProps?: CheckedKeys, treeData?: TreeData[]) => readonly [CheckedKeys | undefined, import("react").Dispatch<import("react").SetStateAction<CheckedKeys | undefined>>];

package/es/components/Tree/_hooks/useTreeState.js

@@ -9,7 +9,7 @@ import { Equal } from "hsu-utils";
 import { normalizeCheckedKeys } from "../_utils/normalizeCheckedKeys";
 
 /**
- * 同步外部 expandedKeys 的 hook
+ * Hook for syncing external expandedKeys
  */
 export var useExpandedKeys = function useExpandedKeys(expandedKeysProps, defaultExpandedKeys) {
   var _useState = useState(defaultExpandedKeys),
@@ -18,10 +18,10 @@ export var useExpandedKeys = function useExpandedKeys(expandedKeysProps, default
     setExpandedKeys = _useState2[1];
   var prevPropsRef = useRef(expandedKeysProps);
   var prevDefaultRef = useRef(defaultExpandedKeys);
-  // 标记用户是否已手动操作过展开状态
+  // Flag indicating whether the user has manually changed the expanded state
   var hasUserInteractedRef = useRef(false);
 
-  // 监听受控模式的 expandedKeysProps 变化
+  // Watch for expandedKeysProps changes in controlled mode
   useEffect(function () {
     if (expandedKeysProps !== undefined && !Equal.ObjEqual(prevPropsRef.current, expandedKeysProps)) {
       prevPropsRef.current = expandedKeysProps;
@@ -29,16 +29,16 @@ export var useExpandedKeys = function useExpandedKeys(expandedKeysProps, default
     }
   }, [expandedKeysProps]);
 
-  // 监听 defaultExpandedKeys 变化（非受控模式下，用于响应异步数据加载）
+  // Watch for defaultExpandedKeys changes (in uncontrolled mode, used to respond to async data loading)
   useEffect(function () {
-    // 只有在非受控模式下，且用户未手动操作过，才响应 defaultExpandedKeys 变化
+    // Only respond to defaultExpandedKeys changes in uncontrolled mode when the user has not manually interacted
     if (expandedKeysProps === undefined && !hasUserInteractedRef.current && !Equal.ObjEqual(prevDefaultRef.current, defaultExpandedKeys)) {
       prevDefaultRef.current = defaultExpandedKeys;
       setExpandedKeys(defaultExpandedKeys);
     }
   }, [defaultExpandedKeys, expandedKeysProps]);
 
-  // 包装 setExpandedKeys，标记用户已手动操作
+  // Wrap setExpandedKeys to mark that the user has manually interacted
   var handleSetExpandedKeys = function handleSetExpandedKeys(keys) {
     hasUserInteractedRef.current = true;
     setExpandedKeys(keys);
@@ -47,11 +47,11 @@ export var useExpandedKeys = function useExpandedKeys(expandedKeysProps, default
 };
 
 /**
- * 同步外部 checkedKeys 的 hook
- * 自动规范化：当父级在 checked 中但子项未全选时，将父级设为半选
+ * Hook for syncing external checkedKeys
+ * Auto-normalizes: when a parent is in checked but its children are not all checked, the parent is set to half-checked
  */
 export var useCheckedKeys = function useCheckedKeys(checkedKeysProps, treeData) {
-  // 规范化 checkedKeys
+  // Normalize checkedKeys
   var normalizedCheckedKeys = useMemo(function () {
     if (!checkedKeysProps || !(treeData !== null && treeData !== void 0 && treeData.length)) {
       return checkedKeysProps;
@@ -66,7 +66,7 @@ export var useCheckedKeys = function useCheckedKeys(checkedKeysProps, treeData)
     setCheckedKeys = _useState4[1];
   var prevNormalizedRef = useRef(normalizedCheckedKeys);
   useEffect(function () {
-    // 只有当规范化后的值真正变化时才更新
+    // Only update when the normalized value has actually changed
     if (normalizedCheckedKeys !== undefined && !Equal.ObjEqual(prevNormalizedRef.current, normalizedCheckedKeys)) {
       prevNormalizedRef.current = normalizedCheckedKeys;
       setCheckedKeys(normalizedCheckedKeys);

package/es/components/Tree/_utils/index.d.ts

@@ -1,44 +1,44 @@
 import { Key } from "react";
 import { TreeData } from "..";
 /**
- * 获取节点的所有子节点 key
- * @param children 子节点数组
- * @returns 所有子节点的 key 数组
+ * Get the keys of all descendant nodes of a node
+ * @param children Array of child nodes
+ * @returns Array of keys of all descendant nodes
  */
 export declare const getAllChildrenKeys: (children: TreeData[]) => Key[];
 /**
- * 在树中查找节点的所有父级节点 key
- * @param targetKey 目标节点的 key
- * @param treeData 树数据
- * @param parentKeys 父级节点 key 数组（递归使用）
- * @returns 所有父级节点的 key 数组，如果未找到则返回空数组
+ * Find the keys of all ancestor nodes of a node in the tree
+ * @param targetKey Key of the target node
+ * @param treeData Tree data
+ * @param parentKeys Array of ancestor node keys (used for recursion)
+ * @returns Array of keys of all ancestor nodes; returns an empty array if not found
  */
 export declare const getAllParentKeys: (targetKey: Key, treeData: TreeData[], parentKeys?: Key[]) => Key[];
 /**
- * 根据 key 查找节点
- * @param targetKey 目标节点的 key
- * @param data 树数据
- * @returns 找到的节点或 null
+ * Find a node by key
+ * @param targetKey Key of the target node
+ * @param data Tree data
+ * @returns The found node, or null
  */
 export declare const findNodeByKey: (targetKey: Key, data: TreeData[]) => TreeData | null;
 /**
- * 搜索过滤树数据
- * @param searchKey 搜索关键词
- * @param data 树数据
- * @returns 过滤后的树数据
+ * Filter tree data by search keyword
+ * @param searchKey Search keyword
+ * @param data Tree data
+ * @returns Filtered tree data
  */
 export declare const filterTreeData: (searchKey: string, data: TreeData[]) => TreeData[];
 /**
- * 根据默认展开层级计算应该展开的节点 keys
- * @param treeData 树数据
- * @param level 展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推）
- * @returns 应该展开的节点 keys 数组
+ * Compute the node keys that should be expanded based on the default expand level
+ * @param treeData Tree data
+ * @param level Expand level (starting from 1: 1 means the first level, 2 the second, and so on)
+ * @returns Array of node keys that should be expanded
  */
 export declare const getExpandedKeysByLevel: (treeData: TreeData[], level: number) => Key[];
 /**
- * 获取节点的完整路径（从根节点到当前节点）
- * @param targetKey 目标节点的 key
- * @param treeData 树数据
- * @returns 节点路径数组，包含从根节点到目标节点的所有节点信息；如果未找到则返回 null
+ * Get the full path of a node (from the root node to the current node)
+ * @param targetKey Key of the target node
+ * @param treeData Tree data
+ * @returns Array of nodes on the path, containing all node info from the root to the target node; returns null if not found
  */
 export declare const getNodePath: (targetKey: Key, treeData: TreeData[]) => TreeData[] | null;

package/es/components/Tree/_utils/index.js

@@ -12,9 +12,9 @@ function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol
 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 _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; }
 /**
- * 获取节点的所有子节点 key
- * @param children 子节点数组
- * @returns 所有子节点的 key 数组
+ * Get the keys of all descendant nodes of a node
+ * @param children Array of child nodes
+ * @returns Array of keys of all descendant nodes
  */
 export var getAllChildrenKeys = function getAllChildrenKeys(children) {
   var keys = [];
@@ -41,11 +41,11 @@ export var getAllChildrenKeys = function getAllChildrenKeys(children) {
 };
 
 /**
- * 在树中查找节点的所有父级节点 key
- * @param targetKey 目标节点的 key
- * @param treeData 树数据
- * @param parentKeys 父级节点 key 数组（递归使用）
- * @returns 所有父级节点的 key 数组，如果未找到则返回空数组
+ * Find the keys of all ancestor nodes of a node in the tree
+ * @param targetKey Key of the target node
+ * @param treeData Tree data
+ * @param parentKeys Array of ancestor node keys (used for recursion)
+ * @returns Array of keys of all ancestor nodes; returns an empty array if not found
  */
 export var getAllParentKeys = function getAllParentKeys(targetKey, treeData) {
   var parentKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
@@ -61,7 +61,7 @@ export var getAllParentKeys = function getAllParentKeys(targetKey, treeData) {
       if ((_node$children2 = node.children) !== null && _node$children2 !== void 0 && _node$children2.length) {
         var newParentKeys = [].concat(_toConsumableArray(parentKeys), [node.key]);
         var found = getAllParentKeys(targetKey, node.children, newParentKeys);
-        // 如果找到了（返回的数组长度大于0或等于newParentKeys），说明在子树中找到了
+        // If found (the returned array length is greater than 0 or equals newParentKeys), the target was found in the subtree
         if (found.length > 0) {
           return found;
         }
@@ -76,10 +76,10 @@ export var getAllParentKeys = function getAllParentKeys(targetKey, treeData) {
 };
 
 /**
- * 根据 key 查找节点
- * @param targetKey 目标节点的 key
- * @param data 树数据
- * @returns 找到的节点或 null
+ * Find a node by key
+ * @param targetKey Key of the target node
+ * @param data Tree data
+ * @returns The found node, or null
  */
 export var findNodeByKey = function findNodeByKey(targetKey, data) {
   var _iterator3 = _createForOfIteratorHelper(data),
@@ -104,10 +104,10 @@ export var findNodeByKey = function findNodeByKey(targetKey, data) {
 };
 
 /**
- * 搜索过滤树数据
- * @param searchKey 搜索关键词
- * @param data 树数据
- * @returns 过滤后的树数据
+ * Filter tree data by search keyword
+ * @param searchKey Search keyword
+ * @param data Tree data
+ * @returns Filtered tree data
  */
 export var filterTreeData = function filterTreeData(searchKey, data) {
   if (!searchKey.trim()) return data;
@@ -136,10 +136,10 @@ export var filterTreeData = function filterTreeData(searchKey, data) {
 };
 
 /**
- * 根据默认展开层级计算应该展开的节点 keys
- * @param treeData 树数据
- * @param level 展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推）
- * @returns 应该展开的节点 keys 数组
+ * Compute the node keys that should be expanded based on the default expand level
+ * @param treeData Tree data
+ * @param level Expand level (starting from 1: 1 means the first level, 2 the second, and so on)
+ * @returns Array of node keys that should be expanded
  */
 export var getExpandedKeysByLevel = function getExpandedKeysByLevel(treeData, level) {
   if (level < 1 || !(treeData !== null && treeData !== void 0 && treeData.length)) {
@@ -153,7 +153,7 @@ export var getExpandedKeysByLevel = function getExpandedKeysByLevel(treeData, le
       for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
         var _node$children3;
         var node = _step5.value;
-        // 如果当前层级小于等于目标层级，则展开该节点
+        // Expand the node if the current level is less than or equal to the target level
         if (currentLevel <= level && (_node$children3 = node.children) !== null && _node$children3 !== void 0 && _node$children3.length) {
           expandedKeys.push(node.key);
           traverse(node.children, currentLevel + 1);
@@ -170,10 +170,10 @@ export var getExpandedKeysByLevel = function getExpandedKeysByLevel(treeData, le
 };
 
 /**
- * 获取节点的完整路径（从根节点到当前节点）
- * @param targetKey 目标节点的 key
- * @param treeData 树数据
- * @returns 节点路径数组，包含从根节点到目标节点的所有节点信息；如果未找到则返回 null
+ * Get the full path of a node (from the root node to the current node)
+ * @param targetKey Key of the target node
+ * @param treeData Tree data
+ * @returns Array of nodes on the path, containing all node info from the root to the target node; returns null if not found
  */
 export var getNodePath = function getNodePath(targetKey, treeData) {
   var findPath = function findPath(nodes) {
@@ -186,12 +186,12 @@ export var getNodePath = function getNodePath(targetKey, treeData) {
         var node = _step6.value;
         var currentPath = [].concat(_toConsumableArray(path), [node]);
 
-        // 找到目标节点
+        // Target node found
         if (node.key === targetKey) {
           return currentPath;
         }
 
-        // 在子节点中继续查找
+        // Continue searching in child nodes
         if ((_node$children4 = node.children) !== null && _node$children4 !== void 0 && _node$children4.length) {
           var found = findPath(node.children, currentPath);
           if (found) {

package/es/components/Tree/_utils/normalizeCheckedKeys.d.ts

@@ -1,8 +1,8 @@
 import { TreeData, CheckedKeys } from "..";
 /**
- * 规范化 checkedKeys：检查父节点，如果子项未全选，将父节点设为半选
- * @param checkedKeys 待规范化的 checkedKeys
- * @param treeData 树数据
- * @returns 规范化后的 checkedKeys
+ * Normalize checkedKeys: check parent nodes; if their children are not all checked, mark the parent as half-checked
+ * @param checkedKeys The checkedKeys to normalize
+ * @param treeData Tree data
+ * @returns Normalized checkedKeys
  */
 export declare const normalizeCheckedKeys: (checkedKeys: CheckedKeys | undefined, treeData: TreeData[]) => CheckedKeys | undefined;

package/es/components/Tree/_utils/normalizeCheckedKeys.js

@@ -4,17 +4,17 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 import { getAllChildrenKeys } from ".";
 
 /**
- * 规范化 checkedKeys：检查父节点，如果子项未全选，将父节点设为半选
- * @param checkedKeys 待规范化的 checkedKeys
- * @param treeData 树数据
- * @returns 规范化后的 checkedKeys
+ * Normalize checkedKeys: check parent nodes; if their children are not all checked, mark the parent as half-checked
+ * @param checkedKeys The checkedKeys to normalize
+ * @param treeData Tree data
+ * @returns Normalized checkedKeys
  */
 export var normalizeCheckedKeys = function normalizeCheckedKeys(checkedKeys, treeData) {
   if (!checkedKeys || !treeData.length) {
     return checkedKeys;
   }
 
-  // 如果是数组格式，转换为对象格式
+  // If in array format, convert to object format
   var checkedSet = new Set();
   var halfCheckedSet = new Set();
   if (Array.isArray(checkedKeys)) {
@@ -31,11 +31,11 @@ export var normalizeCheckedKeys = function normalizeCheckedKeys(checkedKeys, tre
     });
   }
 
-  // 递归遍历所有节点，检查父节点状态
-  // 从最底层开始处理，确保父节点的状态基于子节点的正确状态
+  // Recursively traverse all nodes and check parent node states
+  // Process from the deepest level up so that parent states are based on correct child states
   var processNode = function processNode(node) {
     var _node$children, _node$children2;
-    // 先递归处理子节点（从最底层开始）
+    // Recursively process child nodes first (starting from the deepest level)
     if ((_node$children = node.children) !== null && _node$children !== void 0 && _node$children.length) {
       var _iterator = _createForOfIteratorHelper(node.children),
         _step;
@@ -51,30 +51,30 @@ export var normalizeCheckedKeys = function normalizeCheckedKeys(checkedKeys, tre
       }
     }
 
-    // 然后处理当前节点（父节点）
-    // 如果节点在 checked 中，且有子节点
+    // Then process the current node (the parent)
+    // If the node is in checked and has children
     if (checkedSet.has(node.key) && (_node$children2 = node.children) !== null && _node$children2 !== void 0 && _node$children2.length) {
-      // 获取所有子节点的 key
+      // Get the keys of all descendant nodes
       var allChildrenKeys = getAllChildrenKeys(node.children);
 
-      // 检查所有子节点是否都被勾选
+      // Check whether all descendant nodes are checked
       if (allChildrenKeys.length > 0) {
         var allChildrenChecked = allChildrenKeys.every(function (childKey) {
           return checkedSet.has(childKey);
         });
         if (!allChildrenChecked) {
-          // 如果子节点未全选，将父节点从 checked 中移除，添加到 halfChecked
+          // If the children are not all checked, remove the parent from checked and add it to halfChecked
           checkedSet.delete(node.key);
           halfCheckedSet.add(node.key);
         } else {
-          // 如果所有子节点都被勾选，确保父节点不在 halfChecked 中
+          // If all children are checked, make sure the parent is not in halfChecked
           halfCheckedSet.delete(node.key);
         }
       }
     }
   };
 
-  // 遍历所有根节点
+  // Traverse all root nodes
   var _iterator2 = _createForOfIteratorHelper(treeData),
     _step2;
   try {
@@ -83,7 +83,7 @@ export var normalizeCheckedKeys = function normalizeCheckedKeys(checkedKeys, tre
       processNode(node);
     }
 
-    // 返回规范化后的 checkedKeys
+    // Return the normalized checkedKeys
   } catch (err) {
     _iterator2.e(err);
   } finally {

package/es/components/Tree/index.d.ts

@@ -35,12 +35,12 @@ export interface TreeProps extends Omit<AntdTreeProps, "treeData" | "loadData" |
     hideLeafExpand?: boolean;
     buttonGroup?: ButtonProps[];
     btnPosition?: "left" | "right";
-    /** 默认展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推） */
+    /** Default expand level (starting from 1: 1 means the first level, 2 the second, and so on) */
     defaultExpandLevel?: number;
     hasPermi?: string[];
-    /** 节点被选中时的回调，返回选中节点的完整路径 */
+    /** Callback when a node is selected, returns the full path of the selected node */
     onSelectPath?: (path: TreeData[] | null, selectedKeys: Key[]) => void;
-    /** 点击已选中的节点时是否允许取消选中，默认 true（允许取消选中） */
+    /** Whether clicking an already selected node deselects it; defaults to true (deselection allowed) */
     allowDeselect?: boolean;
     titleSearchBarClassName?: string;
 }

package/es/components/Tree/index.js

@@ -66,12 +66,12 @@ var Tree = function Tree(props) {
     permitted = _usePermissions.permitted;
   var legacyHasSelector = isLegacyHasSelectorBrowser();
 
-  // 生成唯一类名（用于样式隔离）
+  // Generate a unique class name (for style isolation)
   var cls = useMemo(function () {
     return generateRandomStr(10);
   }, []);
-  // 根据 defaultExpandLevel 计算默认展开的 keys
-  // 如果同时提供了 defaultExpandedKeys 和 defaultExpandLevel，优先使用 defaultExpandedKeys
+  // Compute the default expanded keys based on defaultExpandLevel
+  // If both defaultExpandedKeys and defaultExpandLevel are provided, defaultExpandedKeys takes precedence
   var computedDefaultExpandedKeys = useMemo(function () {
     if (defaultExpandedKeys !== undefined) {
       return defaultExpandedKeys;
@@ -82,40 +82,40 @@ var Tree = function Tree(props) {
     return undefined;
   }, [defaultExpandLevel, treeData, defaultExpandedKeys]);
 
-  // 管理展开状态
+  // Manage expanded state
   var _useExpandedKeys = useExpandedKeys(expandedKeysProps, computedDefaultExpandedKeys),
     _useExpandedKeys2 = _slicedToArray(_useExpandedKeys, 2),
     expandedKeys = _useExpandedKeys2[0],
     setExpandedKeys = _useExpandedKeys2[1];
 
-  // 管理勾选状态（自动规范化：父级在 checked 中但子项未全选时，设为半选）
+  // Manage checked state (auto-normalized: a parent in checked whose children are not all checked becomes half-checked)
   var _useCheckedKeys = useCheckedKeys(checkedKeysProps, treeData),
     _useCheckedKeys2 = _slicedToArray(_useCheckedKeys, 2),
     checkedKeys = _useCheckedKeys2[0],
     setCheckedKeys = _useCheckedKeys2[1];
 
-  // 管理选中状态（用于支持 allowDeselect 功能）
+  // Manage selected state (used to support the allowDeselect feature)
   var _React$useState = React.useState(defaultSelectedKeys !== null && defaultSelectedKeys !== void 0 ? defaultSelectedKeys : []),
     _React$useState2 = _slicedToArray(_React$useState, 2),
     internalSelectedKeys = _React$useState2[0],
     setInternalSelectedKeys = _React$useState2[1];
 
-  // 受控模式使用外部传入的 selectedKeys，非受控模式使用内部状态
+  // Controlled mode uses the externally provided selectedKeys; uncontrolled mode uses internal state
   var selectedKeys = selectedKeysProps !== null && selectedKeysProps !== void 0 ? selectedKeysProps : internalSelectedKeys;
 
-  // 处理搜索
+  // Handle search
   var _useTreeSearch = useTreeSearch(treeData, setExpandedKeys),
     searchKey = _useTreeSearch.searchKey,
     handleSearchChange = _useTreeSearch.handleSearchChange,
     filteredTreeData = _useTreeSearch.filteredTreeData;
 
-  // 处理勾选（使用 antd 默认逻辑）
+  // Handle checking (uses antd's default logic)
   var handleCheck = useTreeCheck(setCheckedKeys, onCheck, onChange);
 
-  // 清空节点 title 属性（防止悬浮显示）
+  // Clear the node title attribute (prevents hover tooltip)
   useClearNodeTitle(filteredTreeData, cls);
 
-  // 样式对象（CSS 变量）
+  // Style object (CSS variables)
   var style = useMemo(function () {
     return {
       "--tree-indent-unit-width": typeof indent === "number" ? "".concat(indent, "px") : undefined,
@@ -124,47 +124,48 @@ var Tree = function Tree(props) {
     };
   }, [indent, switchWidth, switchGap]);
 
-  // 使用 ref 保存最新的 onSelectPath 回调和初始化标志，避免闭包陷阱
+  // Store the latest onSelectPath callback and initialization flag in refs to avoid stale closures
   var onSelectPathRef = useRef(onSelectPath);
   var isInitializedRef = useRef(false);
   useEffect(function () {
     onSelectPathRef.current = onSelectPath;
   }, [onSelectPath]);
 
-  // 处理展开事件
+  // Handle expand events
   var handleExpand = useCallback(function (expandedKeys, info) {
     var _treeConfig$onExpand;
     setExpandedKeys(expandedKeys);
     (_treeConfig$onExpand = treeConfig.onExpand) === null || _treeConfig$onExpand === void 0 || _treeConfig$onExpand.call(treeConfig, expandedKeys, info);
   }, [setExpandedKeys, treeConfig]);
 
-  // 处理选中事件
+  // Handle select events
   var handleSelect = useCallback(function (selectedKeys, info) {
     var finalSelectedKeys = selectedKeys;
 
-    // 如果不允许取消选中，且点击的是已选中的节点（info.selected 为 false 表示要取消选中）
-    // 则阻止取消，保持该节点选中
+    // If deselection is not allowed and an already selected node was clicked
+    // (info.selected being false means it is about to be deselected),
+    // block the deselection and keep the node selected
     if (!allowDeselect && !info.selected && info.node.key) {
       finalSelectedKeys = [info.node.key];
     }
 
-    // 非受控模式下，更新内部状态
+    // In uncontrolled mode, update internal state
     if (selectedKeysProps === undefined) {
       setInternalSelectedKeys(finalSelectedKeys);
     }
     onSelect === null || onSelect === void 0 || onSelect(finalSelectedKeys, info);
     if (!onSelectPathRef.current) return;
 
-    // 获取节点路径并调用回调
+    // Get the node path and invoke the callback
     var path = finalSelectedKeys.length > 0 ? getNodePath(finalSelectedKeys[0], treeData) : null;
     onSelectPathRef.current(path, finalSelectedKeys);
   }, [onSelect, treeData, allowDeselect, selectedKeysProps]);
 
-  // 处理初始传入的 selectedKeys 和 defaultSelectedKeys
+  // Handle initially provided selectedKeys and defaultSelectedKeys
   useEffect(function () {
     if (!onSelectPathRef.current || !treeData.length) return;
 
-    // 受控模式：使用 selectedKeysProps
+    // Controlled mode: use selectedKeysProps
     if (selectedKeysProps !== undefined) {
       if (selectedKeysProps.length > 0) {
         var _path = getNodePath(selectedKeysProps[0], treeData);
@@ -176,7 +177,7 @@ var Tree = function Tree(props) {
       return;
     }
 
-    // 非受控模式：只在初始化时使用 defaultSelectedKeys
+    // Uncontrolled mode: only use defaultSelectedKeys on initialization
     if (!isInitializedRef.current && defaultSelectedKeys && defaultSelectedKeys.length > 0) {
       var _path2 = getNodePath(defaultSelectedKeys[0], treeData);
       onSelectPathRef.current(_path2, defaultSelectedKeys);

package/es/components/Tree/index.module.scss

@@ -62,7 +62,7 @@
       }
 
       &:has(> :global(.ant-tree-node-selected)) {
-        background-color: #e6f4ff;
+        background-color: color-mix(in srgb, var(--primary-color) 12%, transparent);
 
         :global(.ant-tree-node-selected) {
           background-color: transparent;
@@ -131,7 +131,7 @@
   &.legacyHasSelectedNodeBackground {
     .treeContainer {
       :global(.ant-tree-treenode):global(.ant-tree-treenode-selected) {
-        background-color: #e6f4ff;
+        background-color: color-mix(in srgb, var(--primary-color) 12%, transparent);
 
         :global(.ant-tree-node-selected) {
           background-color: transparent;

package/es/components/Upload/_components/UploadedItem/index.js

@@ -68,10 +68,10 @@ export var UploadedItem = function UploadedItem(_ref) {
     className: classNames(styles.fileItem, listProps === null || listProps === void 0 ? void 0 : listProps.item),
     children: [/*#__PURE__*/_jsx(Tooltip, {
       title: name,
-      color: "#f2f4f5",
+      color: "var(--cf-subtle)",
       styles: {
         body: {
-          color: "#131212",
+          color: "var(--cf-text)",
           padding: "6px 16px"
         }
       },