@hsu-react/ui 0.0.12 → 0.0.14

package/src/components/Tree/_hooks/useTreeSearch.ts

@@ -3,7 +3,7 @@ import { TreeData } from "..";
 import { filterTreeData } from "../_utils";
 
 /**
- * 处理树搜索的 hook
+ * Hook for handling tree search
  */
 export const useTreeSearch = (
   treeData: TreeData[],
@@ -12,8 +12,8 @@ export const useTreeSearch = (
   const [searchKey, setSearchKey] = useState<string>("");
   const prevSearchKeyRef = useRef<string>("");
 
-  // 处理树数据（搜索过滤）
-  // filterTreeData 内部已经处理了数据拷贝，无需额外 cloneDeep
+  // Process tree data (search filtering)
+  // filterTreeData already handles data copying internally, no extra cloneDeep needed
   const filteredTreeData = useMemo(() => {
     if (!searchKey.trim()) {
       return treeData;
@@ -21,25 +21,25 @@ export const useTreeSearch = (
     return filterTreeData(searchKey, treeData);
   }, [searchKey, treeData]);
 
-  // 处理搜索时的展开逻辑
+  // Handle expand logic while searching
   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/src/components/Tree/_hooks/useTreeState.ts

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

package/src/components/Tree/_utils/index.ts

@@ -2,9 +2,9 @@ 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 const getAllChildrenKeys = (children: TreeData[]): Key[] => {
   const keys: Key[] = [];
@@ -21,11 +21,11 @@ export 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 const getAllParentKeys = (
   targetKey: Key,
@@ -39,7 +39,7 @@ export const getAllParentKeys = (
     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 @@ export const getAllParentKeys = (
 };
 
 /**
- * 根据 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 const findNodeByKey = (
   targetKey: Key,
@@ -71,10 +71,10 @@ export const findNodeByKey = (
 };
 
 /**
- * 搜索过滤树数据
- * @param searchKey 搜索关键词
- * @param data 树数据
- * @returns 过滤后的树数据
+ * Filter tree data by search keyword
+ * @param searchKey Search keyword
+ * @param data Tree data
+ * @returns Filtered tree data
  */
 export const filterTreeData = (
   searchKey: string,
@@ -103,10 +103,10 @@ export const filterTreeData = (
 };
 
 /**
- * 根据默认展开层级计算应该展开的节点 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 const getExpandedKeysByLevel = (
   treeData: TreeData[],
@@ -120,7 +120,7 @@ export const getExpandedKeysByLevel = (
 
   const traverse = (nodes: TreeData[], currentLevel: number) => {
     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);
@@ -134,10 +134,10 @@ export const getExpandedKeysByLevel = (
 };
 
 /**
- * 获取节点的完整路径（从根节点到当前节点）
- * @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 const getNodePath = (
   targetKey: Key,
@@ -150,12 +150,12 @@ export const getNodePath = (
     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/src/components/Tree/_utils/normalizeCheckedKeys.ts

@@ -3,10 +3,10 @@ import { TreeData, CheckedKeys } from "..";
 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 const normalizeCheckedKeys = (
   checkedKeys: CheckedKeys | undefined,
@@ -16,7 +16,7 @@ export const normalizeCheckedKeys = (
     return checkedKeys;
   }
 
-  // 如果是数组格式，转换为对象格式
+  // If in array format, convert to object format
   const checkedSet = new Set<Key>();
   const halfCheckedSet = new Set<Key>();
 
@@ -27,46 +27,46 @@ export const normalizeCheckedKeys = (
     (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: TreeData): void => {
-    // 先递归处理子节点（从最底层开始）
+    // 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 = 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/src/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/src/components/Tree/index.tsx

@@ -62,12 +62,12 @@ export interface TreeProps extends Omit<
   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;
 }
@@ -107,10 +107,10 @@ const Tree: React.FC<TreeProps> = (props) => {
   const { permitted } = usePermissions(hasPermi);
   const legacyHasSelector = isLegacyHasSelectorBrowser();
 
-  // 生成唯一类名（用于样式隔离）
+  // Generate a unique class name (for style isolation)
   const cls = useMemo(() => 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 = useMemo(() => {
     if (defaultExpandedKeys !== undefined) {
       return defaultExpandedKeys;
@@ -121,39 +121,39 @@ const Tree: React.FC<TreeProps> = (props) => {
     return undefined;
   }, [defaultExpandLevel, treeData, defaultExpandedKeys]);
 
-  // 管理展开状态
+  // Manage expanded state
   const [expandedKeys, setExpandedKeys] = 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] = useCheckedKeys(
     checkedKeysProps,
     treeData,
   );
 
-  // 管理选中状态（用于支持 allowDeselect 功能）
+  // Manage selected state (used to support the allowDeselect feature)
   const [internalSelectedKeys, setInternalSelectedKeys] = React.useState<Key[]>(
     defaultSelectedKeys ?? [],
   );
 
-  // 受控模式使用外部传入的 selectedKeys，非受控模式使用内部状态
+  // Controlled mode uses the externally provided selectedKeys; uncontrolled mode uses internal state
   const selectedKeys = selectedKeysProps ?? internalSelectedKeys;
 
-  // 处理搜索
+  // Handle search
   const { searchKey, handleSearchChange, filteredTreeData } = useTreeSearch(
     treeData,
     setExpandedKeys,
   );
 
-  // 处理勾选（使用 antd 默认逻辑）
+  // Handle checking (uses antd's default logic)
   const handleCheck = useTreeCheck(setCheckedKeys, onCheck, onChange);
 
-  // 清空节点 title 属性（防止悬浮显示）
+  // Clear the node title attribute (prevents hover tooltip)
   useClearNodeTitle(filteredTreeData, cls);
 
-  // 样式对象（CSS 变量）
+  // Style object (CSS variables)
   const style = useMemo<CSSProperties>(
     () =>
       ({
@@ -167,7 +167,7 @@ const Tree: React.FC<TreeProps> = (props) => {
     [indent, switchWidth, switchGap],
   );
 
-  // 使用 ref 保存最新的 onSelectPath 回调和初始化标志，避免闭包陷阱
+  // Store the latest onSelectPath callback and initialization flag in refs to avoid stale closures
   const onSelectPathRef = useRef(onSelectPath);
   const isInitializedRef = useRef(false);
 
@@ -175,7 +175,7 @@ const Tree: React.FC<TreeProps> = (props) => {
     onSelectPathRef.current = onSelectPath;
   }, [onSelectPath]);
 
-  // 处理展开事件
+  // Handle expand events
   const handleExpand = useCallback(
     (
       expandedKeys: Key[],
@@ -187,7 +187,7 @@ const Tree: React.FC<TreeProps> = (props) => {
     [setExpandedKeys, treeConfig],
   );
 
-  // 处理选中事件
+  // Handle select events
   const handleSelect = useCallback(
     (
       selectedKeys: Key[],
@@ -195,13 +195,14 @@ const Tree: React.FC<TreeProps> = (props) => {
     ) => {
       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);
       }
@@ -210,7 +211,7 @@ const Tree: React.FC<TreeProps> = (props) => {
 
       if (!onSelectPathRef.current) return;
 
-      // 获取节点路径并调用回调
+      // Get the node path and invoke the callback
       const path =
         finalSelectedKeys.length > 0
           ? getNodePath(finalSelectedKeys[0], treeData)
@@ -220,11 +221,11 @@ const Tree: React.FC<TreeProps> = (props) => {
     [onSelect, treeData, allowDeselect, selectedKeysProps],
   );
 
-  // 处理初始传入的 selectedKeys 和 defaultSelectedKeys
+  // Handle initially provided selectedKeys and defaultSelectedKeys
   useEffect(() => {
     if (!onSelectPathRef.current || !treeData.length) return;
 
-    // 受控模式：使用 selectedKeysProps
+    // Controlled mode: use selectedKeysProps
     if (selectedKeysProps !== undefined) {
       if (selectedKeysProps.length > 0) {
         const path = getNodePath(selectedKeysProps[0], treeData);
@@ -236,7 +237,7 @@ const Tree: React.FC<TreeProps> = (props) => {
       return;
     }
 
-    // 非受控模式：只在初始化时使用 defaultSelectedKeys
+    // Uncontrolled mode: only use defaultSelectedKeys on initialization
     if (
       !isInitializedRef.current &&
       defaultSelectedKeys &&

package/src/components/Upload/_components/UploadedItem/index.tsx

@@ -94,9 +94,9 @@ export const UploadedItem: React.FC<UploadedItemProps> = ({
     <div className={classNames(styles.fileItem, listProps?.item)}>
       <Tooltip
         title={name}
-        color="#f2f4f5"
+        color="var(--cf-subtle)"
         styles={{
-          body: { color: "#131212", padding: "6px 16px" },
+          body: { color: "var(--cf-text)", padding: "6px 16px" },
         }}
       >
         <div className={classNames(styles.fileName, listProps?.itemName)}>

package/src/components/Upload/_components/UploadingItem/index.tsx

@@ -32,9 +32,9 @@ export const UploadingItem: React.FC<UploadingItemProps> = ({
       <div className={styles.uploading}>
         <Tooltip
           title={name}
-          color="#f2f4f5"
+          color="var(--cf-subtle)"
           styles={{
-            body: { color: "#131212", padding: "6px 16px" },
+            body: { color: "var(--cf-text)", padding: "6px 16px" },
           }}
         >
           <div

package/src/components/Upload/_hooks/useUploadFileList.ts

@@ -10,7 +10,7 @@ interface UseUploadFileListProps {
 }
 
 /**
- * 管理上传文件列表状态
+ * Manage the upload file list state
  */
 export function useUploadFileList({
   fileList,

package/src/components/Upload/_hooks/useUploadOperations.ts

@@ -7,7 +7,7 @@ interface UseUploadOperationsProps {
 }
 
 /**
- * 管理上传和下载操作
+ * Manage upload and download operations
  */
 export function useUploadOperations({
   onUploadingList,
@@ -25,7 +25,7 @@ export function useUploadOperations({
     uploadingList: {},
   });
 
-  // 更新时同步到 ref
+  // Sync to the ref on update
   useEffect(() => {
     operationsRef.current.downloading = downloading;
   }, [downloading]);
@@ -41,7 +41,7 @@ export function useUploadOperations({
     }
   }, [uploadingList, lastUploadList, onUploadingList]);
 
-  // 清理函数
+  // Cleanup function
   useEffect(() => {
     return () => {
       const {

package/src/components/Upload/_hooks/useUploadPreview.ts

@@ -2,7 +2,7 @@ import { useState } from "react";
 import { FilePreviewType } from "../../FilePreview";
 
 /**
- * 管理文件预览状态
+ * Manage the file preview state
  */
 export function useUploadPreview() {
   const [file, setFile] = useState<{

package/src/components/Upload/_utils/chunkUpload.ts

@@ -24,7 +24,7 @@ interface ChunkUploadOptions {
 }
 
 /**
- * 分片上传
+ * Chunked upload
  */
 export async function chunkUpload({
   file,
@@ -43,7 +43,7 @@ export async function chunkUpload({
   onError,
   onUploadSuccess,
 }: ChunkUploadOptions) {
-  // 验证文件
+  // Validate the file
   const validation = validateFile({ file, accept, size, en });
   if (!validation.valid) {
     onError?.(validation.error!);
@@ -52,8 +52,8 @@ export async function chunkUpload({
 
   const name = file.name;
   const uploadId = getUUID();
-  const sliceSize = toMB(5); // 切片大小，每个切片5MB
-  const totalSlices = Math.ceil(file.size / sliceSize); // 获取切片数量
+  const sliceSize = toMB(5); // Chunk size, 5MB per chunk
+  const totalSlices = Math.ceil(file.size / sliceSize); // Get the number of chunks
 
   let chunk = 0;
   let postPromises: Promise<{ data?: { code?: number; msg?: string } }>[] = [];

package/src/components/Upload/_utils/createFormData.ts

@@ -1,5 +1,5 @@
 /**
- * 创建 FormData 并添加数据
+ * Create a FormData instance and append data
  */
 export function createFormData(
   data?: Partial<Record<string, string>>

package/src/components/Upload/_utils/extractFileUrl.ts

@@ -1,7 +1,7 @@
 import { UploadFile } from "antd";
 
 /**
- * 从响应中提取文件 URL
+ * Extract the file URL from the response
  */
 export function extractFileUrl(file: UploadFile): UploadFile {
   if (file.response?.data?.list?.[0]?.url) {

package/src/components/Upload/_utils/isSuccessResponse.ts

@@ -1,5 +1,5 @@
 /**
- * 检查响应是否成功
+ * Check whether the response is successful
  */
 export function isSuccessResponse(response: {
   code?: number;

package/src/components/Upload/_utils/normalUpload.ts

@@ -22,7 +22,7 @@ interface NormalUploadOptions {
 }
 
 /**
- * 普通文件上传
+ * Normal file upload
  */
 export async function normalUpload({
   file,
@@ -39,7 +39,7 @@ export async function normalUpload({
   onError,
   onUploadSuccess,
 }: NormalUploadOptions) {
-  // 验证文件
+  // Validate the file
   const validation = validateFile({ file, accept, size, en });
   if (!validation.valid) {
     onError?.(validation.error!);

package/src/components/Upload/_utils/toMB.ts

@@ -1,5 +1,5 @@
 /**
- * 将 MB 转换为字节
+ * Convert MB to bytes
  */
 export function toMB(size: number): number {
   return size * 1024 * 1024;

package/src/components/Upload/_utils/validateFile.ts

@@ -9,7 +9,7 @@ interface ValidateFileOptions {
 }
 
 /**
- * 验证文件格式和大小
+ * Validate file format and size
  */
 export function validateFile({
   file,