@hsu-react/ui 0.0.13 → 0.0.15

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

@@ -7,14 +7,14 @@ exports.useTreeSearch = void 0;
 var _react = require("react");
 var _utils = require("../_utils");
 /**
- * 处理树搜索的 hook
+ * Hook for handling tree search
  */
 const useTreeSearch = (treeData, setExpandedKeys) => {
   const [searchKey, setSearchKey] = (0, _react.useState)("");
   const prevSearchKeyRef = (0, _react.useRef)("");
 
-  // 处理树数据（搜索过滤）
-  // filterTreeData 内部已经处理了数据拷贝，无需额外 cloneDeep
+  // Process tree data (search filtering)
+  // filterTreeData already handles data copying internally, no extra cloneDeep needed
   const filteredTreeData = (0, _react.useMemo)(() => {
     if (!searchKey.trim()) {
       return treeData;
@@ -22,24 +22,24 @@ const useTreeSearch = (treeData, setExpandedKeys) => {
     return (0, _utils.filterTreeData)(searchKey, treeData);
   }, [searchKey, treeData]);
 
-  // 处理搜索时的展开逻辑
+  // Handle expand logic while searching
   (0, _react.useEffect)(() => {
     const trimmedSearchKey = searchKey.trim();
     const 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/lib/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/lib/components/Tree/_hooks/useTreeState.js

@@ -8,16 +8,16 @@ var _react = require("react");
 var _hsuUtils = require("hsu-utils");
 var _normalizeCheckedKeys = require("../_utils/normalizeCheckedKeys");
 /**
- * 同步外部 expandedKeys 的 hook
+ * Hook for syncing external expandedKeys
  */
 const useExpandedKeys = (expandedKeysProps, defaultExpandedKeys) => {
   const [expandedKeys, setExpandedKeys] = (0, _react.useState)(defaultExpandedKeys);
   const prevPropsRef = (0, _react.useRef)(expandedKeysProps);
   const prevDefaultRef = (0, _react.useRef)(defaultExpandedKeys);
-  // 标记用户是否已手动操作过展开状态
+  // Flag indicating whether the user has manually changed the expanded state
   const hasUserInteractedRef = (0, _react.useRef)(false);
 
-  // 监听受控模式的 expandedKeysProps 变化
+  // Watch for expandedKeysProps changes in controlled mode
   (0, _react.useEffect)(() => {
     if (expandedKeysProps !== undefined && !_hsuUtils.Equal.ObjEqual(prevPropsRef.current, expandedKeysProps)) {
       prevPropsRef.current = expandedKeysProps;
@@ -25,16 +25,16 @@ const useExpandedKeys = (expandedKeysProps, defaultExpandedKeys) => {
     }
   }, [expandedKeysProps]);
 
-  // 监听 defaultExpandedKeys 变化（非受控模式下，用于响应异步数据加载）
+  // Watch for defaultExpandedKeys changes (in uncontrolled mode, used to respond to async data loading)
   (0, _react.useEffect)(() => {
-    // 只有在非受控模式下，且用户未手动操作过，才响应 defaultExpandedKeys 变化
+    // Only respond to defaultExpandedKeys changes in uncontrolled mode when the user has not manually interacted
     if (expandedKeysProps === undefined && !hasUserInteractedRef.current && !_hsuUtils.Equal.ObjEqual(prevDefaultRef.current, defaultExpandedKeys)) {
       prevDefaultRef.current = defaultExpandedKeys;
       setExpandedKeys(defaultExpandedKeys);
     }
   }, [defaultExpandedKeys, expandedKeysProps]);
 
-  // 包装 setExpandedKeys，标记用户已手动操作
+  // Wrap setExpandedKeys to mark that the user has manually interacted
   const handleSetExpandedKeys = keys => {
     hasUserInteractedRef.current = true;
     setExpandedKeys(keys);
@@ -43,12 +43,12 @@ const useExpandedKeys = (expandedKeysProps, defaultExpandedKeys) => {
 };
 
 /**
- * 同步外部 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
  */
 exports.useExpandedKeys = useExpandedKeys;
 const useCheckedKeys = (checkedKeysProps, treeData) => {
-  // 规范化 checkedKeys
+  // Normalize checkedKeys
   const normalizedCheckedKeys = (0, _react.useMemo)(() => {
     if (!checkedKeysProps || !treeData?.length) {
       return checkedKeysProps;
@@ -58,7 +58,7 @@ const useCheckedKeys = (checkedKeysProps, treeData) => {
   const [checkedKeys, setCheckedKeys] = (0, _react.useState)(() => normalizedCheckedKeys);
   const prevNormalizedRef = (0, _react.useRef)(normalizedCheckedKeys);
   (0, _react.useEffect)(() => {
-    // 只有当规范化后的值真正变化时才更新
+    // Only update when the normalized value has actually changed
     if (normalizedCheckedKeys !== undefined && !_hsuUtils.Equal.ObjEqual(prevNormalizedRef.current, normalizedCheckedKeys)) {
       prevNormalizedRef.current = normalizedCheckedKeys;
       setCheckedKeys(normalizedCheckedKeys);

package/lib/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/lib/components/Tree/_utils/index.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getNodePath = exports.getExpandedKeysByLevel = exports.getAllParentKeys = exports.getAllChildrenKeys = exports.findNodeByKey = exports.filterTreeData = void 0;
 /**
- * 获取节点的所有子节点 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
  */
 const getAllChildrenKeys = children => {
   const keys = [];
@@ -24,11 +24,11 @@ const 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
  */
 exports.getAllChildrenKeys = getAllChildrenKeys;
 const getAllParentKeys = (targetKey, treeData, parentKeys = []) => {
@@ -39,7 +39,7 @@ const getAllParentKeys = (targetKey, treeData, parentKeys = []) => {
     if (node.children?.length) {
       const newParentKeys = [...parentKeys, node.key];
       const 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;
       }
@@ -49,10 +49,10 @@ const getAllParentKeys = (targetKey, treeData, parentKeys = []) => {
 };
 
 /**
- * 根据 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
  */
 exports.getAllParentKeys = getAllParentKeys;
 const findNodeByKey = (targetKey, data) => {
@@ -69,10 +69,10 @@ const 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
  */
 exports.findNodeByKey = findNodeByKey;
 const filterTreeData = (searchKey, data) => {
@@ -93,10 +93,10 @@ const 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
  */
 exports.filterTreeData = filterTreeData;
 const getExpandedKeysByLevel = (treeData, level) => {
@@ -106,7 +106,7 @@ const getExpandedKeysByLevel = (treeData, level) => {
   const expandedKeys = [];
   const traverse = (nodes, currentLevel) => {
     for (const node of nodes) {
-      // 如果当前层级小于等于目标层级，则展开该节点
+      // Expand the node if the current level is less than or equal to the target level
       if (currentLevel <= level && node.children?.length) {
         expandedKeys.push(node.key);
         traverse(node.children, currentLevel + 1);
@@ -118,10 +118,10 @@ const getExpandedKeysByLevel = (treeData, level) => {
 };
 
 /**
- * 获取节点的完整路径（从根节点到当前节点）
- * @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
  */
 exports.getExpandedKeysByLevel = getExpandedKeysByLevel;
 const getNodePath = (targetKey, treeData) => {
@@ -129,12 +129,12 @@ const getNodePath = (targetKey, treeData) => {
     for (const node of nodes) {
       const currentPath = [...path, node];
 
-      // 找到目标节点
+      // Target node found
       if (node.key === targetKey) {
         return currentPath;
       }
 
-      // 在子节点中继续查找
+      // Continue searching in child nodes
       if (node.children?.length) {
         const found = findPath(node.children, currentPath);
         if (found) {

package/lib/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/lib/components/Tree/_utils/normalizeCheckedKeys.js

@@ -6,17 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.normalizeCheckedKeys = void 0;
 var _ = require(".");
 /**
- * 规范化 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
  */
 const normalizeCheckedKeys = (checkedKeys, treeData) => {
   if (!checkedKeys || !treeData.length) {
     return checkedKeys;
   }
 
-  // 如果是数组格式，转换为对象格式
+  // If in array format, convert to object format
   const checkedSet = new Set();
   const halfCheckedSet = new Set();
   if (Array.isArray(checkedKeys)) {
@@ -26,43 +26,43 @@ const normalizeCheckedKeys = (checkedKeys, treeData) => {
     (checkedKeys.halfChecked || [])?.forEach(key => halfCheckedSet.add(key));
   }
 
-  // 递归遍历所有节点，检查父节点状态
-  // 从最底层开始处理，确保父节点的状态基于子节点的正确状态
+  // 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
   const processNode = node => {
-    // 先递归处理子节点（从最底层开始）
+    // Recursively process child nodes first (starting from the deepest level)
     if (node.children?.length) {
       for (const child of node.children) {
         processNode(child);
       }
     }
 
-    // 然后处理当前节点（父节点）
-    // 如果节点在 checked 中，且有子节点
+    // Then process the current node (the parent)
+    // If the node is in checked and has children
     if (checkedSet.has(node.key) && node.children?.length) {
-      // 获取所有子节点的 key
+      // Get the keys of all descendant nodes
       const allChildrenKeys = (0, _.getAllChildrenKeys)(node.children);
 
-      // 检查所有子节点是否都被勾选
+      // Check whether all descendant nodes are checked
       if (allChildrenKeys.length > 0) {
         const allChildrenChecked = allChildrenKeys.every(childKey => 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
   for (const node of treeData) {
     processNode(node);
   }
 
-  // 返回规范化后的 checkedKeys
+  // Return the normalized checkedKeys
   return {
     checked: Array.from(checkedSet),
     halfChecked: Array.from(halfCheckedSet)

package/lib/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/lib/components/Tree/index.js

@@ -59,10 +59,10 @@ const Tree = props => {
   } = (0, _usePermissions.default)(hasPermi);
   const legacyHasSelector = (0, _cssSupports.isLegacyHasSelectorBrowser)();
 
-  // 生成唯一类名（用于样式隔离）
+  // Generate a unique class name (for style isolation)
   const cls = (0, _react.useMemo)(() => (0, _hsuUtils.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
   const computedDefaultExpandedKeys = (0, _react.useMemo)(() => {
     if (defaultExpandedKeys !== undefined) {
       return defaultExpandedKeys;
@@ -73,78 +73,79 @@ const Tree = props => {
     return undefined;
   }, [defaultExpandLevel, treeData, defaultExpandedKeys]);
 
-  // 管理展开状态
+  // Manage expanded state
   const [expandedKeys, setExpandedKeys] = (0, _useTreeState.useExpandedKeys)(expandedKeysProps, computedDefaultExpandedKeys);
 
-  // 管理勾选状态（自动规范化：父级在 checked 中但子项未全选时，设为半选）
+  // Manage checked state (auto-normalized: a parent in checked whose children are not all checked becomes half-checked)
   const [checkedKeys, setCheckedKeys] = (0, _useTreeState.useCheckedKeys)(checkedKeysProps, treeData);
 
-  // 管理选中状态（用于支持 allowDeselect 功能）
+  // Manage selected state (used to support the allowDeselect feature)
   const [internalSelectedKeys, setInternalSelectedKeys] = _react.default.useState(defaultSelectedKeys ?? []);
 
-  // 受控模式使用外部传入的 selectedKeys，非受控模式使用内部状态
+  // Controlled mode uses the externally provided selectedKeys; uncontrolled mode uses internal state
   const selectedKeys = selectedKeysProps ?? internalSelectedKeys;
 
-  // 处理搜索
+  // Handle search
   const {
     searchKey,
     handleSearchChange,
     filteredTreeData
   } = (0, _useTreeSearch.useTreeSearch)(treeData, setExpandedKeys);
 
-  // 处理勾选（使用 antd 默认逻辑）
+  // Handle checking (uses antd's default logic)
   const handleCheck = (0, _useTreeCheck.useTreeCheck)(setCheckedKeys, onCheck, onChange);
 
-  // 清空节点 title 属性（防止悬浮显示）
+  // Clear the node title attribute (prevents hover tooltip)
   (0, _useClearNodeTitle.useClearNodeTitle)(filteredTreeData, cls);
 
-  // 样式对象（CSS 变量）
+  // Style object (CSS variables)
   const style = (0, _react.useMemo)(() => ({
     "--tree-indent-unit-width": typeof indent === "number" ? `${indent}px` : undefined,
     "--tree-switcher-width": typeof switchWidth === "number" ? `${switchWidth}px` : undefined,
     "--tree-switcher-gap": typeof switchGap === "number" ? `${switchGap}px` : undefined
   }), [indent, switchWidth, switchGap]);
 
-  // 使用 ref 保存最新的 onSelectPath 回调和初始化标志，避免闭包陷阱
+  // Store the latest onSelectPath callback and initialization flag in refs to avoid stale closures
   const onSelectPathRef = (0, _react.useRef)(onSelectPath);
   const isInitializedRef = (0, _react.useRef)(false);
   (0, _react.useEffect)(() => {
     onSelectPathRef.current = onSelectPath;
   }, [onSelectPath]);
 
-  // 处理展开事件
+  // Handle expand events
   const handleExpand = (0, _react.useCallback)((expandedKeys, info) => {
     setExpandedKeys(expandedKeys);
     treeConfig.onExpand?.(expandedKeys, info);
   }, [setExpandedKeys, treeConfig]);
 
-  // 处理选中事件
+  // Handle select events
   const handleSelect = (0, _react.useCallback)((selectedKeys, info) => {
     let 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?.(finalSelectedKeys, info);
     if (!onSelectPathRef.current) return;
 
-    // 获取节点路径并调用回调
+    // Get the node path and invoke the callback
     const path = finalSelectedKeys.length > 0 ? (0, _utils.getNodePath)(finalSelectedKeys[0], treeData) : null;
     onSelectPathRef.current(path, finalSelectedKeys);
   }, [onSelect, treeData, allowDeselect, selectedKeysProps]);
 
-  // 处理初始传入的 selectedKeys 和 defaultSelectedKeys
+  // Handle initially provided selectedKeys and defaultSelectedKeys
   (0, _react.useEffect)(() => {
     if (!onSelectPathRef.current || !treeData.length) return;
 
-    // 受控模式：使用 selectedKeysProps
+    // Controlled mode: use selectedKeysProps
     if (selectedKeysProps !== undefined) {
       if (selectedKeysProps.length > 0) {
         const path = (0, _utils.getNodePath)(selectedKeysProps[0], treeData);
@@ -156,7 +157,7 @@ const Tree = props => {
       return;
     }
 
-    // 非受控模式：只在初始化时使用 defaultSelectedKeys
+    // Uncontrolled mode: only use defaultSelectedKeys on initialization
     if (!isInitializedRef.current && defaultSelectedKeys && defaultSelectedKeys.length > 0) {
       const path = (0, _utils.getNodePath)(defaultSelectedKeys[0], treeData);
       onSelectPathRef.current(path, defaultSelectedKeys);

package/lib/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/lib/components/Upload/_components/UploadedItem/index.js

@@ -70,10 +70,10 @@ const UploadedItem = ({
     className: (0, _classnames.default)(_indexModule.default.fileItem, listProps?.item),
     children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tooltip, {
       title: name,
-      color: "#f2f4f5",
+      color: "var(--cf-subtle)",
       styles: {
         body: {
-          color: "#131212",
+          color: "var(--cf-text)",
           padding: "6px 16px"
         }
       },

package/lib/components/Upload/_components/UploadingItem/index.js

@@ -28,10 +28,10 @@ const UploadingItem = ({
       className: _indexModule.default.uploading,
       children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tooltip, {
         title: name,
-        color: "#f2f4f5",
+        color: "var(--cf-subtle)",
         styles: {
           body: {
-            color: "#131212",
+            color: "var(--cf-text)",
             padding: "6px 16px"
           }
         },

package/lib/components/Upload/_hooks/useUploadFileList.d.ts

@@ -9,7 +9,7 @@ interface UseUploadFileListProps {
     rmFile?: string;
 }
 /**
- * 管理上传文件列表状态
+ * Manage the upload file list state
  */
 export declare function useUploadFileList({ fileList, onChange, rmFile, }: UseUploadFileListProps): {
     fileList: UploadFile<any>[];

package/lib/components/Upload/_hooks/useUploadFileList.js

@@ -8,7 +8,7 @@ var _react = require("react");
 var _hsuUtils = require("hsu-utils");
 var _utils = require("../_utils");
 /**
- * 管理上传文件列表状态
+ * Manage the upload file list state
  */
 function useUploadFileList({
   fileList,

package/lib/components/Upload/_hooks/useUploadOperations.d.ts

@@ -4,7 +4,7 @@ interface UseUploadOperationsProps {
     onUploadingList?: (list: UploadingList) => void;
 }
 /**
- * 管理上传和下载操作
+ * Manage upload and download operations
  */
 export declare function useUploadOperations({ onUploadingList, }: UseUploadOperationsProps): {
     uploadingList: UploadingList;