@hsu-react/ui 0.0.13 → 0.0.15

package/lib/components/Search/_components/SearchBase/index.js

@@ -18,12 +18,12 @@ var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/** 暴露给变体扩展渲染（如高级筛选抽屉）的上下文 */
+/** Context exposed to variant extension rendering (e.g. the advanced filters drawer) */
 
 /**
- * Search 各变体共享的基础实现：
- * 表单渲染、列布局、展开/收起、按钮组、权限控制。
- * 变体只负责自身差异（筛选器、折叠开关、高级筛选抽屉等）。
+ * Base implementation shared by all Search variants:
+ * form rendering, column layout, expand/collapse, button group, permission control.
+ * Variants are only responsible for their own differences (filter, collapse toggle, advanced filters drawer, etc.).
  */
 const SearchBase = props => {
   const {
@@ -93,7 +93,7 @@ const SearchBase = props => {
     columnOffsetWidth
   });
 
-  // 按列分组预计算（用于对齐同列 label 宽度），避免在 map 中逐项重复 filter
+  // Precompute grouping by column (used to align label widths within the same column), avoiding repeated per-item filtering inside map
   const columnGroups = (0, _react.useMemo)(() => {
     const groups = Array.from({
       length: totalColumnNum

package/lib/components/Search/_components/SearchButtons/index.d.ts

@@ -3,9 +3,9 @@ interface SearchButtonsProps {
     onSearch: () => void;
     onReset: () => void;
     searchDisabled?: boolean;
-    /** 查询按钮文本 */
+    /** Search button text */
     searchText?: React.ReactNode;
-    /** 重置按钮文本 */
+    /** Reset button text */
     resetText?: React.ReactNode;
 }
 export declare const SearchButtons: React.FC<SearchButtonsProps>;

package/lib/components/Search/_hooks/useAdaptiveColumnNum.d.ts

@@ -1,13 +1,13 @@
 import { RefObject } from "react";
 /**
- * 根据容器宽度动态调整列数的Hook
- * @param containerRef 容器引用
- * @param totalColumnNum 基础总列数（包括按钮组）
- * @param enabled 是否启用自适应（默认true）
- * @param minColumnNum 最小列数（默认1）
- * @param maxColumnNum 最大列数（默认不限制）
- * @param breakpoints 断点配置，格式：{ width: columnNum }，例如 { 1200: 5, 800: 3 }
- * @param baseWidth 基准宽度，用于计算宽度比例（默认1200px）
- * @returns 调整后的总列数
+ * Hook that dynamically adjusts the column count based on container width
+ * @param containerRef Container ref
+ * @param totalColumnNum Base total column count (including the button group)
+ * @param enabled Whether adaptive mode is enabled (default true)
+ * @param minColumnNum Minimum column count (default 1)
+ * @param maxColumnNum Maximum column count (unlimited by default)
+ * @param breakpoints Breakpoint config, format: { width: columnNum }, e.g. { 1200: 5, 800: 3 }
+ * @param baseWidth Base width used to compute the width ratio (default 1200px)
+ * @returns Adjusted total column count
  */
 export declare function useAdaptiveColumnNum(containerRef: RefObject<HTMLDivElement>, totalColumnNum: number, enabled?: boolean, minColumnNum?: number, maxColumnNum?: number, breakpoints?: Record<number, number>, baseWidth?: number): number;

package/lib/components/Search/_hooks/useAdaptiveColumnNum.js

@@ -6,15 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.useAdaptiveColumnNum = useAdaptiveColumnNum;
 var _react = require("react");
 /**
- * 根据容器宽度动态调整列数的Hook
- * @param containerRef 容器引用
- * @param totalColumnNum 基础总列数（包括按钮组）
- * @param enabled 是否启用自适应（默认true）
- * @param minColumnNum 最小列数（默认1）
- * @param maxColumnNum 最大列数（默认不限制）
- * @param breakpoints 断点配置，格式：{ width: columnNum }，例如 { 1200: 5, 800: 3 }
- * @param baseWidth 基准宽度，用于计算宽度比例（默认1200px）
- * @returns 调整后的总列数
+ * Hook that dynamically adjusts the column count based on container width
+ * @param containerRef Container ref
+ * @param totalColumnNum Base total column count (including the button group)
+ * @param enabled Whether adaptive mode is enabled (default true)
+ * @param minColumnNum Minimum column count (default 1)
+ * @param maxColumnNum Maximum column count (unlimited by default)
+ * @param breakpoints Breakpoint config, format: { width: columnNum }, e.g. { 1200: 5, 800: 3 }
+ * @param baseWidth Base width used to compute the width ratio (default 1200px)
+ * @returns Adjusted total column count
  */
 function useAdaptiveColumnNum(containerRef, totalColumnNum, enabled = true, minColumnNum = 1, maxColumnNum, breakpoints, baseWidth = 1200) {
   const [adaptiveColumnNum, setAdaptiveColumnNum] = (0, _react.useState)(totalColumnNum);
@@ -28,9 +28,9 @@ function useAdaptiveColumnNum(containerRef, totalColumnNum, enabled = true, minC
       const containerWidth = containerRef.current.offsetWidth;
       let calculatedColumnNum = totalColumnNum;
 
-      // 如果提供了断点配置，优先使用断点
+      // If breakpoint config is provided, use breakpoints first
       if (breakpoints) {
-        const sortedBreakpoints = Object.keys(breakpoints)?.map(Number).sort((a, b) => b - a); // 从大到小排序
+        const sortedBreakpoints = Object.keys(breakpoints)?.map(Number).sort((a, b) => b - a); // Sort descending
 
         for (const breakpoint of sortedBreakpoints) {
           if (containerWidth >= breakpoint) {
@@ -39,13 +39,13 @@ function useAdaptiveColumnNum(containerRef, totalColumnNum, enabled = true, minC
           }
         }
       } else {
-        // 默认策略：根据容器宽度自动计算
-        // 基于基础列数，根据容器宽度比例调整
+        // Default strategy: compute automatically from container width
+        // Based on the base column count, adjusted by the container width ratio
         const widthRatio = containerWidth / baseWidth;
         calculatedColumnNum = Math.round(totalColumnNum * widthRatio);
       }
 
-      // 应用最小值和最大值限制
+      // Apply min and max limits
       if (calculatedColumnNum < minColumnNum) {
         calculatedColumnNum = minColumnNum;
       }
@@ -55,24 +55,24 @@ function useAdaptiveColumnNum(containerRef, totalColumnNum, enabled = true, minC
       setAdaptiveColumnNum(calculatedColumnNum);
     };
     const resizeObserver = new ResizeObserver(() => {
-      // 使用 requestAnimationFrame 延迟到下一帧，确保DOM已更新
+      // Use requestAnimationFrame to defer to the next frame, ensuring the DOM has updated
       requestAnimationFrame(() => {
         calculateColumnNum();
       });
     });
 
-    // 延迟观察，确保 ref 已被赋值
+    // Defer observation to ensure the ref has been assigned
     const observeContainer = () => {
       if (containerRef.current) {
         resizeObserver.observe(containerRef.current);
       } else {
-        // 如果 ref 还未赋值，稍后重试
+        // If the ref is not assigned yet, retry later
         requestAnimationFrame(observeContainer);
       }
     };
     observeContainer();
 
-    // 监听窗口大小变化
+    // Listen for window resize
     const handleWindowResize = () => {
       requestAnimationFrame(() => {
         calculateColumnNum();
@@ -80,7 +80,7 @@ function useAdaptiveColumnNum(containerRef, totalColumnNum, enabled = true, minC
     };
     window.addEventListener("resize", handleWindowResize);
 
-    // 初始计算（延迟执行以确保DOM已渲染）
+    // Initial calculation (deferred to ensure the DOM has rendered)
     requestAnimationFrame(() => {
       calculateColumnNum();
     });

package/lib/components/Search/_hooks/useSearchCommon.d.ts

@@ -47,6 +47,6 @@ export interface UseSearchCommonReturn {
     permitted: boolean;
 }
 /**
- * 提取所有 Search 组件的通用逻辑
+ * Extracts the common logic shared by all Search components
  */
 export declare const useSearchCommon: (params: UseSearchCommonParams) => UseSearchCommonReturn;

package/lib/components/Search/_hooks/useSearchCommon.js

@@ -16,7 +16,7 @@ var _utils = require("../_utils");
 var _indexModule = _interopRequireDefault(require("../index.module.scss"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
- * 提取所有 Search 组件的通用逻辑
+ * Extracts the common logic shared by all Search components
  */
 const useSearchCommon = params => {
   const {
@@ -50,23 +50,23 @@ const useSearchCommon = params => {
   const buttonGroupRef = (0, _react.useRef)(null);
   const cls = (0, _react.useMemo)(() => (0, _hsuUtils.generateRandomStr)(10), []);
 
-  // 提取可见搜索项
+  // Extract visible search items
   const visibleSearchItems = (0, _react.useMemo)(() => {
     return processedSearchItems.filter(item => item.visible !== false);
   }, [processedSearchItems]);
 
-  // 提取可见的更多搜索项
+  // Extract visible "more" search items
   const visibleMoreSearchItems = (0, _react.useMemo)(() => {
     return moreSearchItems.filter(item => item.visible !== false);
   }, [moreSearchItems]);
 
-  // 计算可见的搜索项数量
+  // Count of visible search items
   const visibleSearchItemCount = visibleSearchItems.length;
 
-  // 计算总列数（包括按钮组）
+  // Total column count (including the button group)
   const baseTotalColumnNum = columnNum + 1;
 
-  // 根据容器宽度动态调整列数
+  // Dynamically adjust column count based on container width
   const totalColumnNum = (0, _useAdaptiveColumnNum.useAdaptiveColumnNum)(containerRef, baseTotalColumnNum, autoAdaptWidth, 1,
   // minColumnNum
   undefined,
@@ -75,10 +75,10 @@ const useSearchCommon = params => {
   // breakpoints
   baseWidth);
 
-  // 计算调整后的搜索项列数（不包括按钮组）
+  // Adjusted search-item column count (excluding the button group)
   const adaptiveColumnNum = Math.max(1, totalColumnNum - 1);
 
-  // 使用基于宽度的展开/收起控制
+  // Use width-based expand/collapse control
   const {
     expand,
     setExpand,
@@ -90,14 +90,14 @@ const useSearchCommon = params => {
     searchData
   });
 
-  // 计算当前应该显示的搜索项
+  // Compute the search items that should currently be displayed
   const currentSearchItems = (0, _react.useMemo)(() => {
     if (showAllSearchItems || !!moreSearchItems?.length) {
       if (expand) return [...visibleSearchItems, ...visibleMoreSearchItems];
       return visibleSearchItems;
     }
 
-    // 计算按钮组宽度和列宽（用于判断是否需要显示更多项）
+    // Compute button group width and column width (used to decide whether more items should be displayed)
     let buttonGroupWidth;
     let columnWidth;
     if (!expand) {
@@ -106,7 +106,7 @@ const useSearchCommon = params => {
       columnWidth = result.columnWidth;
     }
 
-    // 否则使用计算函数
+    // Otherwise use the calculation function
     return (0, _utils.calculateVisibleItems)(processedSearchItems, expand, adaptiveColumnNum, visibleItemCount, autoAdaptWidth, buttonGroupWidth, columnWidth);
   }, [showAllSearchItems, moreSearchItems?.length, expand, processedSearchItems, adaptiveColumnNum, visibleItemCount, autoAdaptWidth, visibleSearchItems, visibleMoreSearchItems, columnOffsetWidth]);
   const onResetClick = (0, _react.useCallback)(() => {
@@ -122,33 +122,33 @@ const useSearchCommon = params => {
     });
   }, [form, onSearch]);
 
-  // 检查是否有自定义宽度
+  // Check whether any item has a custom width
   const hasCustomWidth = (0, _react.useMemo)(() => {
     return processedSearchItems.some(item => item.width !== undefined);
   }, [processedSearchItems]);
 
-  // 计算实际应该显示的项数（考虑按钮组宽度大于列宽的情况）
+  // Compute the actual number of items to display (accounting for the case where the button group is wider than a column)
   const actualDisplayCount = (0, _react.useMemo)(() => {
     if (hasCustomWidth) {
       return visibleItemCount;
     }
 
-    // 计算按钮组宽度和列宽
+    // Compute button group width and column width
     const {
       buttonGroupWidth,
       columnWidth
     } = (0, _utils.calculateButtonGroupAndColumnWidth)(containerRef, buttonGroupRef, adaptiveColumnNum, columnOffsetWidth);
 
-    // 判断按钮组宽度是否大于列宽，如果是，则显示 实际搜索项数量+1
+    // If the button group is wider than a column, display actual search item count + 1
     if ((0, _utils.shouldDisplayExtraItem)(buttonGroupWidth, columnWidth, adaptiveColumnNum, visibleSearchItemCount)) {
       return adaptiveColumnNum + 1;
     }
     return adaptiveColumnNum;
   }, [hasCustomWidth, adaptiveColumnNum, columnOffsetWidth, visibleSearchItemCount, visibleItemCount]);
 
-  // 计算是否显示展开按钮
+  // Determine whether to show the expand button
   const showExpandButton = (0, _react.useMemo)(() => {
-    // 如果有更多搜索项，显示展开按钮
+    // If there are "more" search items, show the expand button
     if (showAllSearchItems || !!moreSearchItems?.length) {
       if (visibleMoreSearchItems?.length) {
         return true;
@@ -156,21 +156,21 @@ const useSearchCommon = params => {
       return false;
     }
 
-    // 如果有自定义宽度，根据可见项数量判断
+    // If there are custom widths, decide based on the visible item count
     if (hasCustomWidth) {
       return visibleSearchItemCount > visibleItemCount;
     }
-    // 否则根据实际显示项数判断（考虑按钮组宽度大于列宽的情况）
+    // Otherwise decide based on the actual display count (accounting for the case where the button group is wider than a column)
     return visibleSearchItemCount > actualDisplayCount;
   }, [showAllSearchItems, moreSearchItems, hasCustomWidth, visibleSearchItemCount, actualDisplayCount, visibleMoreSearchItems?.length, visibleItemCount]);
 
-  // 检查按钮组是否有权限的按钮
+  // Check whether the button group contains any permitted button
   const hasPermittedButtons = (0, _react.useCallback)(buttonGroup => {
     if (!buttonGroup?.length) return false;
     return buttonGroup.some(button => checkPermission(button.hasPermi));
   }, [checkPermission]);
 
-  // 权限和内容检查
+  // Permission and content check
   const shouldRender = (0, _react.useMemo)(() => {
     return Boolean(hasPermittedButtons(beforeButtonGroup) || hasPermittedButtons(affterButtonGroup) || permitted && searchItems.length > 0);
   }, [searchItems.length, beforeButtonGroup, affterButtonGroup, permitted, hasPermittedButtons]);

package/lib/components/Search/_hooks/useSearchExpand.d.ts

@@ -1,18 +1,18 @@
 /// <reference types="react" />
 import { FormItemProps } from "../../FormItem";
 /**
- * 基于宽度自适应控制展开/收起的Hook
- * @param containerRef 容器引用
- * @param buttonGroupRef 按钮组引用
- * @param itemClassName 搜索项的className
- * @param itemCount 搜索项总数
- * @param columnNum 列数
- * @param autoAdaptWidth 是否启用自适应宽度
- * @param defaultExpanded 默认是否展开
- * @param onExpandChange 展开状态变化回调
- * @param searchItems 搜索项配置数组（可选）
- * @param showAllSearchItems 是否显示所有搜索项
- * @returns 展开状态及控制方法
+ * Hook that controls expand/collapse adaptively based on width
+ * @param containerRef Container ref
+ * @param buttonGroupRef Button group ref
+ * @param itemClassName className of the search items
+ * @param itemCount Total number of search items
+ * @param columnNum Column count
+ * @param autoAdaptWidth Whether adaptive width is enabled
+ * @param defaultExpanded Whether expanded by default
+ * @param onExpandChange Callback when expand state changes
+ * @param searchItems Search item config array (optional)
+ * @param showAllSearchItems Whether to show all search items
+ * @returns Expand state and control methods
  */
 export declare function useSearchExpand(containerRef: React.RefObject<HTMLDivElement>, buttonGroupRef: React.RefObject<HTMLDivElement>, itemClassName: string, itemCount: number, columnNum: number, autoAdaptWidth: boolean, defaultExpanded: boolean, onExpandChange?: (expand: boolean) => void, searchItems?: FormItemProps[], showAllSearchItems?: boolean, columnOffsetWidth?: number): {
     expand: boolean;

package/lib/components/Search/_hooks/useSearchExpand.js

@@ -7,18 +7,18 @@ exports.useSearchExpand = useSearchExpand;
 var _react = require("react");
 var _utils = require("../_utils");
 /**
- * 基于宽度自适应控制展开/收起的Hook
- * @param containerRef 容器引用
- * @param buttonGroupRef 按钮组引用
- * @param itemClassName 搜索项的className
- * @param itemCount 搜索项总数
- * @param columnNum 列数
- * @param autoAdaptWidth 是否启用自适应宽度
- * @param defaultExpanded 默认是否展开
- * @param onExpandChange 展开状态变化回调
- * @param searchItems 搜索项配置数组（可选）
- * @param showAllSearchItems 是否显示所有搜索项
- * @returns 展开状态及控制方法
+ * Hook that controls expand/collapse adaptively based on width
+ * @param containerRef Container ref
+ * @param buttonGroupRef Button group ref
+ * @param itemClassName className of the search items
+ * @param itemCount Total number of search items
+ * @param columnNum Column count
+ * @param autoAdaptWidth Whether adaptive width is enabled
+ * @param defaultExpanded Whether expanded by default
+ * @param onExpandChange Callback when expand state changes
+ * @param searchItems Search item config array (optional)
+ * @param showAllSearchItems Whether to show all search items
+ * @returns Expand state and control methods
  */
 function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount, columnNum, autoAdaptWidth, defaultExpanded, onExpandChange, searchItems, showAllSearchItems, columnOffsetWidth = 0) {
   const [expand, setExpand] = (0, _react.useState)(defaultExpanded);
@@ -31,38 +31,38 @@ function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount,
     const calculateVisibleItems = () => {
       if (!containerRef.current || !buttonGroupRef.current) return;
       const containerWidth = container.offsetWidth;
-      // 减去padding
+      // Subtract padding
       const availableWidth = containerWidth - 30; // 15px padding on each side
 
-      // 获取按钮组的实际宽度（计算所有子元素宽度总和）
+      // Get the actual width of the button group (sum of all child element widths)
       const buttonGroupWidth = (0, _utils.measureButtonGroupWidth)(buttonGroupRef.current) ?? 0;
 
-      // 获取所有搜索项元素
+      // Get all search item elements
       const items = container.querySelectorAll(`${itemClassName}`);
 
-      // 计算第一行能放下的搜索项数量
+      // Compute how many search items fit in the first row
       let count = 0;
       let usedWidth = 0;
-      const gap = 10; // 项之间的间距
+      const gap = 10; // Gap between items
 
-      // 计算默认单个项的宽度（容器宽度除以列数）
+      // Compute the default width of a single item (container width divided by column count)
       const defaultItemWidth = (availableWidth - (columnNum - 1) * gap) / columnNum - columnOffsetWidth;
 
-      // 遍历所有搜索项（包括未渲染的）
+      // Iterate over all search items (including unrendered ones)
       for (let i = 0; i < itemCount; i++) {
         let itemWidth = 0;
 
-        // 如果DOM中有这个item，使用实际宽度
+        // If this item exists in the DOM, use its actual width
         if (i < items.length) {
           const item = items[i];
           itemWidth = item.offsetWidth;
         } else if (searchItems && searchItems[i]?.width !== undefined) {
-          // 如果DOM中没有，但有设置宽度，使用设置的宽度
+          // If not in the DOM but a width is configured, use the configured width
           const configWidth = searchItems[i].width;
           if (typeof configWidth === "number") {
             itemWidth = configWidth;
           } else if (typeof configWidth === "string") {
-            // 处理百分比或像素值
+            // Handle percentage or pixel values
             if (configWidth.endsWith("%")) {
               const percent = parseFloat(configWidth) / 100;
               itemWidth = availableWidth * percent;
@@ -71,14 +71,14 @@ function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount,
             }
           }
         } else {
-          // 如果DOM中没有且没有设置宽度，使用默认计算宽度
+          // If not in the DOM and no width is configured, use the default computed width
           itemWidth = defaultItemWidth;
         }
 
-        // 计算加上当前项后的总宽度（包括gap）
+        // Compute the total width after adding the current item (including gap)
         const nextWidth = usedWidth + itemWidth + (i > 0 ? gap : 0);
 
-        // 检查是否还能放下按钮组（需要预留gap和按钮组宽度）
+        // Check whether the button group still fits (must reserve the gap and the button group width)
         if (nextWidth + gap + buttonGroupWidth <= availableWidth) {
           count++;
           usedWidth = nextWidth;
@@ -87,25 +87,25 @@ function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount,
         }
       }
 
-      // 至少显示1个搜索项
+      // Show at least 1 search item
       count = Math.max(1, count);
       setVisibleItemCount(count);
 
-      // 如果所有项都能显示，则不需要展开
+      // If all items can be displayed, expanding is not needed
       if (count >= itemCount) {
         setExpand(false);
       }
     };
     const resizeObserver = new ResizeObserver(() => {
-      // 使用 requestAnimationFrame 延迟到下一帧，确保DOM已更新
+      // Use requestAnimationFrame to defer to the next frame, ensuring the DOM has updated
       requestAnimationFrame(() => {
         calculateVisibleItems();
       });
     });
 
-    // MutationObserver 监听DOM变化
+    // MutationObserver watches for DOM changes
     const mutationObserver = new MutationObserver(() => {
-      // 使用 requestAnimationFrame 延迟到下一帧
+      // Use requestAnimationFrame to defer to the next frame
       requestAnimationFrame(() => {
         calculateVisibleItems();
       });
@@ -118,7 +118,7 @@ function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount,
       attributeFilter: ["class", "style"]
     });
 
-    // 监听窗口大小变化
+    // Listen for window resize
     const handleWindowResize = () => {
       requestAnimationFrame(() => {
         calculateVisibleItems();
@@ -126,7 +126,7 @@ function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount,
     };
     window.addEventListener("resize", handleWindowResize);
 
-    // 初始计算（延迟执行以确保DOM已渲染）
+    // Initial calculation (deferred to ensure the DOM has rendered)
     requestAnimationFrame(() => {
       calculateVisibleItems();
     });

package/lib/components/Search/_hooks/useSearchForm.d.ts

@@ -4,7 +4,7 @@ interface UseSearchFormProps {
     searchData?: Record<string, unknown>;
 }
 /**
- * 管理搜索表单数据
+ * Manages search form data
  */
 export declare function useSearchForm({ form, searchData }: UseSearchFormProps): void;
 export {};

package/lib/components/Search/_hooks/useSearchForm.js

@@ -7,7 +7,7 @@ exports.useSearchForm = useSearchForm;
 var _react = require("react");
 var _hsuUtils = require("hsu-utils");
 /**
- * 管理搜索表单数据
+ * Manages search form data
  */
 function useSearchForm({
   form,

package/lib/components/Search/_hooks/useSearchItems.d.ts

@@ -1,10 +1,11 @@
 import { FormItemProps } from "../../FormItem";
 /**
- * 管理搜索项状态
+ * Manages search item state
  *
- * 通过 useMemo 直接从入参派生，仅把用户在 FilterDropdown 里手动切换的
- * visible 覆盖保存为 state；避免 useEffect 镜像 prop 时因为父组件传入
- * 新数组引用而反复 setState，从而触发 Maximum update depth 循环。
+ * Derives directly from the input via useMemo, storing only the visible
+ * overrides the user manually toggles in FilterDropdown as state; this avoids
+ * repeated setState when a useEffect mirrors the prop and the parent passes a
+ * new array reference, which would trigger a Maximum update depth loop.
  */
 export declare function useSearchItems(searchItems: FormItemProps[]): {
     searchItems: FormItemProps[];

package/lib/components/Search/_hooks/useSearchItems.js

@@ -6,11 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.useSearchItems = useSearchItems;
 var _react = require("react");
 /**
- * 管理搜索项状态
+ * Manages search item state
  *
- * 通过 useMemo 直接从入参派生，仅把用户在 FilterDropdown 里手动切换的
- * visible 覆盖保存为 state；避免 useEffect 镜像 prop 时因为父组件传入
- * 新数组引用而反复 setState，从而触发 Maximum update depth 循环。
+ * Derives directly from the input via useMemo, storing only the visible
+ * overrides the user manually toggles in FilterDropdown as state; this avoids
+ * repeated setState when a useEffect mirrors the prop and the parent passes a
+ * new array reference, which would trigger a Maximum update depth loop.
  */
 function useSearchItems(searchItems) {
   const [visibilityOverrides, setVisibilityOverrides] = (0, _react.useState)({});

package/lib/components/Search/_types/index.d.ts

@@ -3,7 +3,7 @@ import { ReactNode } from "react";
 import { FormItemProps } from "../../FormItem";
 import { ChakraButtonProps } from "../../Button";
 /**
- * Search 组件的基础属性接口
+ * Base props interface for the Search component
  */
 export interface BaseSearchProps {
     searchItems?: FormItemProps[];
@@ -13,36 +13,36 @@ export interface BaseSearchProps {
     className?: string;
     externalForm?: FormInstance;
     hasPermi?: string[];
-    /** 搜索项列数（不包括按钮组，总列数为 columnNum + 1） */
+    /** Search item column count (excluding the button group; total column count is columnNum + 1) */
     columnNum?: number;
     beforeButtonGroup?: ChakraButtonProps[];
     affterButtonGroup?: ChakraButtonProps[];
     searchData?: Record<string, unknown>;
     minLabelWidth?: boolean | number;
-    /** 默认是否展开 */
+    /** Whether expanded by default */
     defaultExpanded?: boolean;
-    /** 展开状态变化时的回调 */
+    /** Callback when the expand state changes */
     onExpandChange?: (expand: boolean) => void;
-    /** 是否启用基于宽度的自适应布局（默认显示一行包括按钮） */
+    /** Whether to enable width-based adaptive layout (by default shows one row including buttons) */
     autoAdaptWidth?: boolean;
-    /** 自适应布局的基准宽度（默认1200px） */
+    /** Base width for adaptive layout (default 1200px) */
     baseWidth?: number;
     onValuesChange?: (value: Record<string, unknown>, values: Record<string, unknown>) => void;
     searchDisabled?: boolean;
     showAllSearchItems?: boolean;
-    /** 查询按钮文本 */
+    /** Search button text */
     searchText?: ReactNode;
-    /** 重置按钮文本 */
+    /** Reset button text */
     resetText?: ReactNode;
-    /** 列偏移宽度，用于调整列宽计算（默认 0） */
+    /** Column offset width, used to adjust column width calculation (default 0) */
     columnOffsetWidth?: number;
 }
 /**
- * 带筛选器的 Search 组件属性接口
+ * Props interface for the Search component with filter
  */
 export interface SearchPropsWithFilter extends BaseSearchProps {
-    /** 是否显示筛选器 */
+    /** Whether to show the filter */
     setFilter?: boolean;
-    /** FilterDropdown 勾选项变化时的回调 */
+    /** Callback when checked items change in FilterDropdown */
     onFilterChange?: (items: FormItemProps[]) => void;
 }

package/lib/components/Search/_utils/calculateButtonGroupAndColumnWidth.d.ts

@@ -1,11 +1,11 @@
 import { RefObject } from "react";
 /**
- * 计算按钮组宽度和列宽
- * @param containerRef 容器引用
- * @param buttonGroupRef 按钮组引用
- * @param adaptiveColumnNum 自适应列数
- * @param columnOffsetWidth 列偏移宽度（默认 0）
- * @returns 按钮组宽度和列宽
+ * Computes the button group width and column width
+ * @param containerRef Container ref
+ * @param buttonGroupRef Button group ref
+ * @param adaptiveColumnNum Adaptive column count
+ * @param columnOffsetWidth Column offset width (default 0)
+ * @returns Button group width and column width
  */
 export declare function calculateButtonGroupAndColumnWidth(containerRef: RefObject<HTMLDivElement>, buttonGroupRef: RefObject<HTMLDivElement>, adaptiveColumnNum: number, columnOffsetWidth?: number): {
     buttonGroupWidth: number | undefined;