@hsu-react/ui 0.0.12 → 0.0.14

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

@@ -21,15 +21,15 @@ import { SearchButtons } from "../SearchButtons";
 import { ExpandButton } from "../ExpandButton";
 import { FilterDropdown } from "../FilterDropdown";
 
-/** 暴露给变体扩展渲染（如高级筛选抽屉）的上下文 */
+/** Context exposed to variant extension rendering (e.g. the advanced filters drawer) */
 import { createElement as _createElement } from "react";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
 /**
- * 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.).
  */
 var SearchBase = function SearchBase(props) {
   var _props$searchItems = props.searchItems,
@@ -108,7 +108,7 @@ var SearchBase = function SearchBase(props) {
     shouldRender = _useSearchCommon.shouldRender,
     permitted = _useSearchCommon.permitted;
 
-  // 按列分组预计算（用于对齐同列 label 宽度），避免在 map 中逐项重复 filter
+  // Precompute grouping by column (used to align label widths within the same column), avoiding repeated per-item filtering inside map
   var columnGroups = useMemo(function () {
     var groups = Array.from({
       length: totalColumnNum

package/es/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/es/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/es/components/Search/_hooks/useAdaptiveColumnNum.js

@@ -8,15 +8,15 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useEffect, useState } 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 function useAdaptiveColumnNum(containerRef, totalColumnNum) {
   var enabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
@@ -38,12 +38,12 @@ export function useAdaptiveColumnNum(containerRef, totalColumnNum) {
       var containerWidth = containerRef.current.offsetWidth;
       var calculatedColumnNum = totalColumnNum;
 
-      // 如果提供了断点配置，优先使用断点
+      // If breakpoint config is provided, use breakpoints first
       if (breakpoints) {
         var _Object$keys;
         var sortedBreakpoints = (_Object$keys = Object.keys(breakpoints)) === null || _Object$keys === void 0 ? void 0 : _Object$keys.map(Number).sort(function (a, b) {
           return b - a;
-        }); // 从大到小排序
+        }); // Sort descending
         var _iterator = _createForOfIteratorHelper(sortedBreakpoints),
           _step;
         try {
@@ -60,13 +60,13 @@ export function useAdaptiveColumnNum(containerRef, totalColumnNum) {
           _iterator.f();
         }
       } else {
-        // 默认策略：根据容器宽度自动计算
-        // 基于基础列数，根据容器宽度比例调整
+        // Default strategy: compute automatically from container width
+        // Based on the base column count, adjusted by the container width ratio
         var widthRatio = containerWidth / baseWidth;
         calculatedColumnNum = Math.round(totalColumnNum * widthRatio);
       }
 
-      // 应用最小值和最大值限制
+      // Apply min and max limits
       if (calculatedColumnNum < minColumnNum) {
         calculatedColumnNum = minColumnNum;
       }
@@ -76,24 +76,24 @@ export function useAdaptiveColumnNum(containerRef, totalColumnNum) {
       setAdaptiveColumnNum(calculatedColumnNum);
     };
     var resizeObserver = new ResizeObserver(function () {
-      // 使用 requestAnimationFrame 延迟到下一帧，确保DOM已更新
+      // Use requestAnimationFrame to defer to the next frame, ensuring the DOM has updated
       requestAnimationFrame(function () {
         calculateColumnNum();
       });
     });
 
-    // 延迟观察，确保 ref 已被赋值
+    // Defer observation to ensure the ref has been assigned
     var observeContainer = function 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
     var handleWindowResize = function handleWindowResize() {
       requestAnimationFrame(function () {
         calculateColumnNum();
@@ -101,7 +101,7 @@ export function useAdaptiveColumnNum(containerRef, totalColumnNum) {
     };
     window.addEventListener("resize", handleWindowResize);
 
-    // 初始计算（延迟执行以确保DOM已渲染）
+    // Initial calculation (deferred to ensure the DOM has rendered)
     requestAnimationFrame(function () {
       calculateColumnNum();
     });

package/es/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/es/components/Search/_hooks/useSearchCommon.js

@@ -19,7 +19,7 @@ import { useSearchExpand } from "./useSearchExpand";
 import { cleanSearchData, calculateVisibleItems, calculateButtonGroupAndColumnWidth, shouldDisplayExtraItem } from "../_utils";
 import styles from "../index.module.scss";
 /**
- * 提取所有 Search 组件的通用逻辑
+ * Extracts the common logic shared by all Search components
  */
 export var useSearchCommon = function useSearchCommon(params) {
   var form = params.form,
@@ -55,27 +55,27 @@ export var useSearchCommon = function useSearchCommon(params) {
     return generateRandomStr(10);
   }, []);
 
-  // 提取可见搜索项
+  // Extract visible search items
   var visibleSearchItems = useMemo(function () {
     return processedSearchItems.filter(function (item) {
       return item.visible !== false;
     });
   }, [processedSearchItems]);
 
-  // 提取可见的更多搜索项
+  // Extract visible "more" search items
   var visibleMoreSearchItems = useMemo(function () {
     return moreSearchItems.filter(function (item) {
       return item.visible !== false;
     });
   }, [moreSearchItems]);
 
-  // 计算可见的搜索项数量
+  // Count of visible search items
   var visibleSearchItemCount = visibleSearchItems.length;
 
-  // 计算总列数（包括按钮组）
+  // Total column count (including the button group)
   var baseTotalColumnNum = columnNum + 1;
 
-  // 根据容器宽度动态调整列数
+  // Dynamically adjust column count based on container width
   var totalColumnNum = useAdaptiveColumnNum(containerRef, baseTotalColumnNum, autoAdaptWidth, 1,
   // minColumnNum
   undefined,
@@ -84,10 +84,10 @@ export var useSearchCommon = function useSearchCommon(params) {
   // breakpoints
   baseWidth);
 
-  // 计算调整后的搜索项列数（不包括按钮组）
+  // Adjusted search-item column count (excluding the button group)
   var adaptiveColumnNum = Math.max(1, totalColumnNum - 1);
 
-  // 使用基于宽度的展开/收起控制
+  // Use width-based expand/collapse control
   var _useSearchExpand = useSearchExpand(containerRef, buttonGroupRef, ".".concat(cls, " .").concat(styles.item), visibleSearchItemCount, adaptiveColumnNum, autoAdaptWidth, defaultExpanded, onExpandChange, processedSearchItems, showAllSearchItems || !!(moreSearchItems !== null && moreSearchItems !== void 0 && moreSearchItems.length), columnOffsetWidth),
     expand = _useSearchExpand.expand,
     setExpand = _useSearchExpand.setExpand,
@@ -98,14 +98,14 @@ export var useSearchCommon = function useSearchCommon(params) {
     searchData: searchData
   });
 
-  // 计算当前应该显示的搜索项
+  // Compute the search items that should currently be displayed
   var currentSearchItems = useMemo(function () {
     if (showAllSearchItems || !!(moreSearchItems !== null && moreSearchItems !== void 0 && moreSearchItems.length)) {
       if (expand) return [].concat(_toConsumableArray(visibleSearchItems), _toConsumableArray(visibleMoreSearchItems));
       return visibleSearchItems;
     }
 
-    // 计算按钮组宽度和列宽（用于判断是否需要显示更多项）
+    // Compute button group width and column width (used to decide whether more items should be displayed)
     var buttonGroupWidth;
     var columnWidth;
     if (!expand) {
@@ -114,7 +114,7 @@ export var useSearchCommon = function useSearchCommon(params) {
       columnWidth = result.columnWidth;
     }
 
-    // 否则使用计算函数
+    // Otherwise use the calculation function
     return calculateVisibleItems(processedSearchItems, expand, adaptiveColumnNum, visibleItemCount, autoAdaptWidth, buttonGroupWidth, columnWidth);
   }, [showAllSearchItems, moreSearchItems === null || moreSearchItems === void 0 ? void 0 : moreSearchItems.length, expand, processedSearchItems, adaptiveColumnNum, visibleItemCount, autoAdaptWidth, visibleSearchItems, visibleMoreSearchItems, columnOffsetWidth]);
   var onResetClick = useCallback(function () {
@@ -130,34 +130,34 @@ export var useSearchCommon = function useSearchCommon(params) {
     });
   }, [form, onSearch]);
 
-  // 检查是否有自定义宽度
+  // Check whether any item has a custom width
   var hasCustomWidth = useMemo(function () {
     return processedSearchItems.some(function (item) {
       return 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)
   var actualDisplayCount = useMemo(function () {
     if (hasCustomWidth) {
       return visibleItemCount;
     }
 
-    // 计算按钮组宽度和列宽
+    // Compute button group width and column width
     var _calculateButtonGroup = calculateButtonGroupAndColumnWidth(containerRef, buttonGroupRef, adaptiveColumnNum, columnOffsetWidth),
       buttonGroupWidth = _calculateButtonGroup.buttonGroupWidth,
       columnWidth = _calculateButtonGroup.columnWidth;
 
-    // 判断按钮组宽度是否大于列宽，如果是，则显示 实际搜索项数量+1
+    // If the button group is wider than a column, display actual search item count + 1
     if (shouldDisplayExtraItem(buttonGroupWidth, columnWidth, adaptiveColumnNum, visibleSearchItemCount)) {
       return adaptiveColumnNum + 1;
     }
     return adaptiveColumnNum;
   }, [hasCustomWidth, adaptiveColumnNum, columnOffsetWidth, visibleSearchItemCount, visibleItemCount]);
 
-  // 计算是否显示展开按钮
+  // Determine whether to show the expand button
   var showExpandButton = useMemo(function () {
-    // 如果有更多搜索项，显示展开按钮
+    // If there are "more" search items, show the expand button
     if (showAllSearchItems || !!(moreSearchItems !== null && moreSearchItems !== void 0 && moreSearchItems.length)) {
       if (visibleMoreSearchItems !== null && visibleMoreSearchItems !== void 0 && visibleMoreSearchItems.length) {
         return true;
@@ -165,15 +165,15 @@ export var useSearchCommon = function 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 === null || visibleMoreSearchItems === void 0 ? void 0 : visibleMoreSearchItems.length, visibleItemCount]);
 
-  // 检查按钮组是否有权限的按钮
+  // Check whether the button group contains any permitted button
   var hasPermittedButtons = useCallback(function (buttonGroup) {
     if (!(buttonGroup !== null && buttonGroup !== void 0 && buttonGroup.length)) return false;
     return buttonGroup.some(function (button) {
@@ -181,7 +181,7 @@ export var useSearchCommon = function useSearchCommon(params) {
     });
   }, [checkPermission]);
 
-  // 权限和内容检查
+  // Permission and content check
   var shouldRender = useMemo(function () {
     return Boolean(hasPermittedButtons(beforeButtonGroup) || hasPermittedButtons(affterButtonGroup) || permitted && searchItems.length > 0);
   }, [searchItems.length, beforeButtonGroup, affterButtonGroup, permitted, hasPermittedButtons]);

package/es/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/es/components/Search/_hooks/useSearchExpand.js

@@ -8,18 +8,18 @@ import { useState, useEffect, useCallback } from "react";
 import { measureButtonGroupWidth } from "../_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
  */
 export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, itemCount, columnNum, autoAdaptWidth, defaultExpanded, onExpandChange, searchItems, showAllSearchItems) {
   var columnOffsetWidth = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : 0;
@@ -40,39 +40,39 @@ export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, ite
       var _measureButtonGroupWi;
       if (!containerRef.current || !buttonGroupRef.current) return;
       var containerWidth = container.offsetWidth;
-      // 减去padding
+      // Subtract padding
       var availableWidth = containerWidth - 30; // 15px padding on each side
 
-      // 获取按钮组的实际宽度（计算所有子元素宽度总和）
+      // Get the actual width of the button group (sum of all child element widths)
       var buttonGroupWidth = (_measureButtonGroupWi = measureButtonGroupWidth(buttonGroupRef.current)) !== null && _measureButtonGroupWi !== void 0 ? _measureButtonGroupWi : 0;
 
-      // 获取所有搜索项元素
+      // Get all search item elements
       var items = container.querySelectorAll("".concat(itemClassName));
 
-      // 计算第一行能放下的搜索项数量
+      // Compute how many search items fit in the first row
       var count = 0;
       var usedWidth = 0;
-      var gap = 10; // 项之间的间距
+      var gap = 10; // Gap between items
 
-      // 计算默认单个项的宽度（容器宽度除以列数）
+      // Compute the default width of a single item (container width divided by column count)
       var defaultItemWidth = (availableWidth - (columnNum - 1) * gap) / columnNum - columnOffsetWidth;
 
-      // 遍历所有搜索项（包括未渲染的）
+      // Iterate over all search items (including unrendered ones)
       for (var i = 0; i < itemCount; i++) {
         var _searchItems$i;
         var itemWidth = 0;
 
-        // 如果DOM中有这个item，使用实际宽度
+        // If this item exists in the DOM, use its actual width
         if (i < items.length) {
           var item = items[i];
           itemWidth = item.offsetWidth;
         } else if (searchItems && ((_searchItems$i = searchItems[i]) === null || _searchItems$i === void 0 ? void 0 : _searchItems$i.width) !== undefined) {
-          // 如果DOM中没有，但有设置宽度，使用设置的宽度
+          // If not in the DOM but a width is configured, use the configured width
           var configWidth = searchItems[i].width;
           if (typeof configWidth === "number") {
             itemWidth = configWidth;
           } else if (typeof configWidth === "string") {
-            // 处理百分比或像素值
+            // Handle percentage or pixel values
             if (configWidth.endsWith("%")) {
               var percent = parseFloat(configWidth) / 100;
               itemWidth = availableWidth * percent;
@@ -81,14 +81,14 @@ export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, ite
             }
           }
         } 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)
         var 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;
@@ -97,25 +97,25 @@ export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, ite
         }
       }
 
-      // 至少显示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);
       }
     };
     var resizeObserver = new ResizeObserver(function () {
-      // 使用 requestAnimationFrame 延迟到下一帧，确保DOM已更新
+      // Use requestAnimationFrame to defer to the next frame, ensuring the DOM has updated
       requestAnimationFrame(function () {
         calculateVisibleItems();
       });
     });
 
-    // MutationObserver 监听DOM变化
+    // MutationObserver watches for DOM changes
     var mutationObserver = new MutationObserver(function () {
-      // 使用 requestAnimationFrame 延迟到下一帧
+      // Use requestAnimationFrame to defer to the next frame
       requestAnimationFrame(function () {
         calculateVisibleItems();
       });
@@ -128,7 +128,7 @@ export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, ite
       attributeFilter: ["class", "style"]
     });
 
-    // 监听窗口大小变化
+    // Listen for window resize
     var handleWindowResize = function handleWindowResize() {
       requestAnimationFrame(function () {
         calculateVisibleItems();
@@ -136,7 +136,7 @@ export function useSearchExpand(containerRef, buttonGroupRef, itemClassName, ite
     };
     window.addEventListener("resize", handleWindowResize);
 
-    // 初始计算（延迟执行以确保DOM已渲染）
+    // Initial calculation (deferred to ensure the DOM has rendered)
     requestAnimationFrame(function () {
       calculateVisibleItems();
     });

package/es/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/es/components/Search/_hooks/useSearchForm.js

@@ -1,7 +1,7 @@
 import { useEffect } from "react";
 import { Equal } from "hsu-utils";
 /**
- * 管理搜索表单数据
+ * Manages search form data
  */
 export function useSearchForm(_ref) {
   var form = _ref.form,

package/es/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/es/components/Search/_hooks/useSearchItems.js

@@ -12,11 +12,12 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useCallback, useMemo, useState } from "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.
  */
 export function useSearchItems(searchItems) {
   var _useState = useState({}),

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