@hsu-react/ui 0.0.13 → 0.0.14

package/lib/components/TextEllipsis/index.js

@@ -9,11 +9,11 @@ var _react = require("react");
 var _indexModule = _interopRequireDefault(require("./index.module.scss"));
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// 默认 Tooltip 宽度
+// Default Tooltip width
 const DEFAULT_TOOLTIP_WIDTH = 200;
 /**
- * 文本溢出组件
- * 当文本溢出时自动显示 Tooltip，并省略超出文本
+ * Text overflow component
+ * Automatically shows a Tooltip when the text overflows, and truncates the overflowing text
  */
 const TextEllipsis = ({
   children,
@@ -29,14 +29,14 @@ const TextEllipsis = ({
   const measureRef = (0, _react.useRef)(null);
   const [isOverflow, setIsOverflow] = (0, _react.useState)(false);
   const [truncatedText, setTruncatedText] = (0, _react.useState)(children);
-  // 容器实际渲染宽度：未声明 width 时（如表格列宽动态分配）作为 Tooltip 宽度
+  // Actual rendered container width: used as the Tooltip width when width is not declared (e.g. dynamically allocated table column widths)
   const [measuredWidth, setMeasuredWidth] = (0, _react.useState)(0);
   (0, _react.useEffect)(() => {
     const element = textRef.current;
     const measureElement = measureRef.current;
     if (!element || !measureElement) return;
 
-    // 将 children 转换为字符串
+    // Convert children to a string
     const getTextContent = node => {
       if (typeof node === "string" || typeof node === "number") {
         return String(node);
@@ -47,7 +47,7 @@ const TextEllipsis = ({
       return "";
     };
 
-    // 同步测量元素的样式
+    // Sync the measure element's styles
     const computedStyle = window.getComputedStyle(element);
     measureElement.style.fontSize = computedStyle.fontSize;
     measureElement.style.fontFamily = computedStyle.fontFamily;
@@ -58,17 +58,17 @@ const TextEllipsis = ({
     measureElement.style.border = computedStyle.border;
     measureElement.style.boxSizing = computedStyle.boxSizing;
 
-    // 计算截断后的文本（省略前面）
+    // Compute the truncated text (truncating the beginning)
     const calculateTruncatedText = (text, maxWidth) => {
       const ellipsis = "...";
 
-      // 如果整个文本都不溢出，直接返回
+      // If the entire text does not overflow, return it directly
       measureElement.textContent = text;
       if (measureElement.offsetWidth <= maxWidth) {
         return text;
       }
 
-      // 二分查找找到合适的截断点
+      // Binary search for the appropriate truncation point
       let left = 0;
       let right = text.length;
       let result = text;
@@ -91,7 +91,7 @@ const TextEllipsis = ({
       setIsOverflow(isTextOverflow);
       setMeasuredWidth(element.clientWidth);
 
-      // 如果是省略前面且文本溢出，需要计算截断后的文本
+      // If truncating the beginning and the text overflows, the truncated text must be computed
       if (ellipsisPosition === "start" && isTextOverflow && textContent) {
         const maxWidth = element.clientWidth;
         const truncated = calculateTruncatedText(textContent, maxWidth);
@@ -102,14 +102,14 @@ const TextEllipsis = ({
     };
     update();
 
-    // 容器宽度动态变化（如表格列宽重分配、窗口 resize）时重测溢出与宽度
+    // Re-measure overflow and width when the container width changes dynamically (e.g. table column width redistribution, window resize)
     const resizeObserver = new ResizeObserver(update);
     resizeObserver.observe(element);
     return () => resizeObserver.disconnect();
   }, [children, ellipsisPosition, style]);
 
-  // 计算 Tooltip 的宽度：显式 width 优先；未声明（或百分比）时用容器实际渲染宽度，
-  // 实测不到再回退 defaultWidth
+  // Compute the Tooltip width: an explicit width takes priority; when not declared (or a percentage),
+  // use the container's actual rendered width, falling back to defaultWidth if measurement fails
   const getTooltipWidth = () => {
     const defaultWidth = tooltipConfig?.defaultWidth ?? DEFAULT_TOOLTIP_WIDTH;
     const dynamicWidth = measuredWidth > 0 ? measuredWidth : defaultWidth;
@@ -120,7 +120,7 @@ const TextEllipsis = ({
   };
   const tooltipWidth = getTooltipWidth();
 
-  // 从 tooltipConfig 中提取配置，移除 defaultWidth
+  // Extract config from tooltipConfig, removing defaultWidth
   const {
     defaultWidth,
     styles,
@@ -128,14 +128,14 @@ const TextEllipsis = ({
   } = tooltipConfig || {};
   void defaultWidth;
 
-  // 尝试将 children 格式化为 JSON
+  // Try to format children as JSON
   const formatTooltipTitle = content => {
     if (typeof content !== "string") return content;
     try {
       const parsed = JSON.parse(content);
       return JSON.stringify(parsed, null, 2);
     } catch {
-      // 如果不是有效的 JSON，返回原内容
+      // If not valid JSON, return the original content
       return content;
     }
   };
@@ -151,13 +151,13 @@ const TextEllipsis = ({
       ref: textRef,
       className: `${_indexModule.default.textElement} ${ellipsisPosition === "end" ? _indexModule.default.ellipsisEnd : _indexModule.default.ellipsisStart} ${className || ""}`,
       style: style,
-      title: "" // 禁用浏览器默认 tooltip
+      title: "" // Disable the browser's default tooltip
       ,
       children: ellipsisPosition === "start" ? truncatedText : children
     })]
   });
 
-  // 只在溢出且未禁用时显示 Tooltip
+  // Show the Tooltip only when overflowing and not disabled
   if (isOverflow && !disabled) {
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tooltip, {
       arrow: false,

package/lib/components/Tree/_components/TitleSearchBar/index.js

@@ -25,7 +25,7 @@ const TitleSearchBar = ({
   titleClassName,
   className
 }) => {
-  // 渲染按钮组
+  // Render the button group
   const renderButtonGroup = (0, _react.useMemo)(() => {
     if (!buttonGroup?.length) {
       return null;
@@ -37,7 +37,7 @@ const TitleSearchBar = ({
       }, idx))
     });
   }, [buttonGroup]);
-  // 如果没有内容，不渲染
+  // Do not render if there is no content
   if (!search && !title && !buttonGroup?.length) {
     return null;
   }

package/lib/components/Tree/_hooks/useClearNodeTitle.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
 /**
- * 清除树节点 title 属性的 Hook
- * 当数据变更后，将所有 span.ant-tree-node-content-wrapper 的 title 设置为空
- * @param treeData 树数据
- * @param cls 树组件的唯一类名（用于精确定位）
+ * Hook that clears the title attribute of tree nodes
+ * After data changes, sets the title of all span.ant-tree-node-content-wrapper elements to empty
+ * @param treeData Tree data
+ * @param cls Unique class name of the tree component (used for precise targeting)
  */
 export declare const useClearNodeTitle: <T extends unknown[]>(treeData: T, cls?: string) => import("react").RefObject<HTMLDivElement>;

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

@@ -6,24 +6,24 @@ Object.defineProperty(exports, "__esModule", {
 exports.useClearNodeTitle = void 0;
 var _react = require("react");
 /**
- * 清除树节点 title 属性的 Hook
- * 当数据变更后，将所有 span.ant-tree-node-content-wrapper 的 title 设置为空
- * @param treeData 树数据
- * @param cls 树组件的唯一类名（用于精确定位）
+ * Hook that clears the title attribute of tree nodes
+ * After data changes, sets the title of all span.ant-tree-node-content-wrapper elements to empty
+ * @param treeData Tree data
+ * @param cls Unique class name of the tree component (used for precise targeting)
  */
 const useClearNodeTitle = (treeData, cls) => {
   const containerRef = (0, _react.useRef)(null);
   (0, _react.useEffect)(() => {
-    // 使用 requestAnimationFrame 确保 DOM 已更新
+    // Use requestAnimationFrame to ensure the DOM has been updated
     const timer = requestAnimationFrame(() => {
-      // 根据类名查找或使用 ref
+      // Look up by class name, or fall back to the ref
       const container = cls ? document.querySelector(`.${cls}`) : containerRef.current;
       if (!container) return;
       setTimeout(() => {
-        // 获取所有 ant-tree-node-content-wrapper 元素
+        // Get all ant-tree-node-content-wrapper elements
         const nodes = container.querySelectorAll("span.ant-tree-node-content-wrapper");
 
-        // 清空每个元素的 title 属性
+        // Clear the title attribute of each element
         nodes?.forEach(node => {
           if (node instanceof HTMLElement) {
             node.title = "";

package/lib/components/Tree/_hooks/useTreeCheck.d.ts

@@ -1,7 +1,7 @@
 import { TreeProps as AntdTreeProps } from "antd";
 import { CheckedKeys } from "..";
 /**
- * 处理树勾选的 hook
- * 使用 antd 默认逻辑，不做额外操作
+ * Hook for handling tree checking
+ * Uses antd's default logic without any extra operations
  */
 export declare const useTreeCheck: (setCheckedKeys: React.Dispatch<React.SetStateAction<CheckedKeys | undefined>>, onCheck?: AntdTreeProps["onCheck"], onChange?: ((checked: CheckedKeys) => void) | undefined) => (checked: CheckedKeys, info: Parameters<NonNullable<AntdTreeProps["onCheck"]>>[1]) => void;

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

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

package/lib/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/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;