@oceanbase/design 1.0.0-alpha.2 → 1.0.0-alpha.21

package/es/filter/components/ResponsiveFilterGroup.js

@@ -0,0 +1,477 @@
+"use client";
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { Children, isValidElement, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { Flex } from 'antd';
+import { FilterOutlined } from '@oceanbase/icons';
+import Button from "../../button";
+import FilterWrap from "./FilterWrap";
+import ConfigProvider from "../../config-provider";
+import defaultLocale from "../../locale/en-US";
+import { FilterProvider } from "../FilterContext";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+// 检查元素是否是 Filter 组件（通过 __isFilterComponent 静态标记识别）
+var isFilterComponent = function isFilterComponent(child) {
+  var _child$props;
+  var type = child.type;
+  if (type !== null && type !== void 0 && type.__isFilterComponent) return true;
+  if ((_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children && /*#__PURE__*/isValidElement(child.props.children)) {
+    var innerType = child.props.children.type;
+    if (innerType !== null && innerType !== void 0 && innerType.__isFilterComponent) return true;
+  }
+  return false;
+};
+
+// 检查子元素是否可以被折叠（只有 Filter 组件默认可折叠，其他组件需要显式设置 collapsible）
+var isCollapsibleCheck = function isCollapsibleCheck(child) {
+  var childProps = child.props;
+  if ((childProps === null || childProps === void 0 ? void 0 : childProps.collapsible) !== undefined) {
+    return childProps.collapsible !== false;
+  }
+  if (childProps !== null && childProps !== void 0 && childProps.children && /*#__PURE__*/isValidElement(childProps.children)) {
+    var _innerChild$props;
+    var innerChild = childProps.children;
+    if (((_innerChild$props = innerChild.props) === null || _innerChild$props === void 0 ? void 0 : _innerChild$props.collapsible) !== undefined) {
+      return innerChild.props.collapsible !== false;
+    }
+  }
+  return isFilterComponent(child);
+};
+
+// 检查子元素是否应该始终折叠
+var isAlwaysCollapseCheck = function isAlwaysCollapseCheck(child) {
+  var childProps = child.props;
+  if ((childProps === null || childProps === void 0 ? void 0 : childProps.alwaysCollapse) !== undefined) {
+    return childProps.alwaysCollapse === true;
+  }
+  if (childProps !== null && childProps !== void 0 && childProps.children && /*#__PURE__*/isValidElement(childProps.children)) {
+    var _innerChild$props2;
+    var innerChild = childProps.children;
+    if (((_innerChild$props2 = innerChild.props) === null || _innerChild$props2 === void 0 ? void 0 : _innerChild$props2.alwaysCollapse) !== undefined) {
+      return innerChild.props.alwaysCollapse === true;
+    }
+  }
+  return false;
+};
+var ResponsiveFilterGroup = function ResponsiveFilterGroup(_ref) {
+  var children = _ref.children,
+    _ref$gap = _ref.gap,
+    gap = _ref$gap === void 0 ? 8 : _ref$gap,
+    label = _ref.label,
+    _ref$icon = _ref.icon,
+    icon = _ref$icon === void 0 ? /*#__PURE__*/_jsx(FilterOutlined, {}) : _ref$icon,
+    onApply = _ref.onApply,
+    onClearAll = _ref.onClearAll,
+    _ref$showActions = _ref.showActions,
+    showActions = _ref$showActions === void 0 ? true : _ref$showActions,
+    style = _ref.style,
+    extra = _ref.extra,
+    _ref$showCount = _ref.showCount,
+    showCount = _ref$showCount === void 0 ? true : _ref$showCount,
+    customLocale = _ref.locale;
+  var _useContext = useContext(ConfigProvider.ConfigContext),
+    contextLocale = _useContext.locale;
+  var filterLocale = _objectSpread(_objectSpread(_objectSpread({}, defaultLocale.Filter), contextLocale === null || contextLocale === void 0 ? void 0 : contextLocale.Filter), customLocale);
+  var filterLabel = label !== null && label !== void 0 ? label : filterLocale === null || filterLocale === void 0 ? void 0 : filterLocale.filters;
+  var containerRef = useRef(null);
+  var filterButtonRef = useRef(null);
+  var moreButtonMeasureRef = useRef(null);
+  var cachedWidths = useRef([]);
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    visibleCount = _useState2[0],
+    setVisibleCount = _useState2[1];
+  var _useState3 = useState([]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    filterValues = _useState4[0],
+    setFilterValues = _useState4[1];
+  var childrenArray = useMemo(function () {
+    return Children.toArray(children).filter(isValidElement);
+  }, [children]);
+  var childInfo = useMemo(function () {
+    return childrenArray.map(function (child, index) {
+      return {
+        child: child,
+        index: index,
+        isCollapsible: isCollapsibleCheck(child),
+        isAlwaysCollapse: isAlwaysCollapseCheck(child)
+      };
+    });
+  }, [childrenArray]);
+  var collapsibleItems = useMemo(function () {
+    return childInfo.filter(function (item) {
+      return item.isCollapsible;
+    });
+  }, [childInfo]);
+  var alwaysCollapseItems = useMemo(function () {
+    return collapsibleItems.filter(function (item) {
+      return item.isAlwaysCollapse;
+    });
+  }, [collapsibleItems]);
+  var normalCollapsibleItems = useMemo(function () {
+    return collapsibleItems.filter(function (item) {
+      return !item.isAlwaysCollapse;
+    });
+  }, [collapsibleItems]);
+
+  // 当 children 结构变化（增删/重排）时才重置为测量模式
+  // 不能用 childrenArray 引用比较，因为 JSX 每次渲染都产生新引用
+  var childrenStructureKey = childrenArray.map(function (c) {
+    var _c$key;
+    return (_c$key = c.key) !== null && _c$key !== void 0 ? _c$key : c.type;
+  }).join(',');
+  var _useState5 = useState(childrenStructureKey),
+    _useState6 = _slicedToArray(_useState5, 2),
+    prevStructureKey = _useState6[0],
+    setPrevStructureKey = _useState6[1];
+  if (childrenStructureKey !== prevStructureKey) {
+    setPrevStructureKey(childrenStructureKey);
+    setVisibleCount(null);
+  }
+  var isMeasuring = visibleCount === null;
+
+  // 纯计算函数：根据容器宽度计算可显示的可折叠项数量
+  var calculateVisibleCount = useCallback(function (containerWidth) {
+    var _moreButtonMeasureRef;
+    if (normalCollapsibleItems.length === 0) return 0;
+    var widths = cachedWidths.current;
+    if (widths.length === 0) return normalCollapsibleItems.length;
+    var uncollapsibleTotalWidth = 0;
+    var uncollapsibleCount = 0;
+    childInfo.forEach(function (info) {
+      if (!info.isCollapsible) {
+        uncollapsibleTotalWidth += widths[info.index] || 0;
+        uncollapsibleCount++;
+      }
+    });
+    var moreWidth = ((_moreButtonMeasureRef = moreButtonMeasureRef.current) === null || _moreButtonMeasureRef === void 0 ? void 0 : _moreButtonMeasureRef.offsetWidth) || 0;
+    var hasAlwaysCollapse = alwaysCollapseItems.length > 0;
+    var visibleWidth = 0;
+    var count = 0;
+    for (var i = 0; i < normalCollapsibleItems.length; i++) {
+      var itemWidth = widths[normalCollapsibleItems[i].index] || 0;
+      var newWidth = visibleWidth + itemWidth;
+      var remaining = normalCollapsibleItems.length - i - 1;
+      var needMore = remaining > 0 || hasAlwaysCollapse;
+      var totalItems = uncollapsibleCount + count + 1 + (needMore ? 1 : 0);
+      var totalGaps = totalItems > 1 ? (totalItems - 1) * gap : 0;
+      var totalWidth = uncollapsibleTotalWidth + newWidth + (needMore ? moreWidth : 0) + totalGaps;
+      if (totalWidth <= containerWidth) {
+        visibleWidth = newWidth;
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }, [childInfo, normalCollapsibleItems, alwaysCollapseItems, gap]);
+
+  // 使用 ref 保存最新的计算函数，避免 ResizeObserver 等 effect 频繁重建
+  var calculateRef = useRef(calculateVisibleCount);
+  calculateRef.current = calculateVisibleCount;
+
+  // Effect 1: 测量模式下，读取所有子元素宽度并计算 visibleCount
+  useLayoutEffect(function () {
+    if (!containerRef.current || !isMeasuring) return;
+    var items = containerRef.current.querySelectorAll('[data-filter-item]');
+    var newWidths = [];
+    items.forEach(function (el) {
+      var idx = Number(el.dataset.filterItem);
+      if (!isNaN(idx)) {
+        newWidths[idx] = el.offsetWidth;
+      }
+    });
+    cachedWidths.current = newWidths;
+    var count = calculateRef.current(containerRef.current.offsetWidth);
+    setVisibleCount(count);
+  }, [isMeasuring]);
+
+  // Effect 2: 监听容器大小变化，用缓存宽度重新计算（不需要重新测量）
+  useEffect(function () {
+    if (!containerRef.current) return;
+    var el = containerRef.current;
+    var ro = new ResizeObserver(function () {
+      if (cachedWidths.current.length === 0) return;
+      var count = calculateRef.current(el.offsetWidth);
+      setVisibleCount(function (prev) {
+        return prev === count ? prev : count;
+      });
+    });
+    ro.observe(el);
+    return function () {
+      return ro.disconnect();
+    };
+  }, []);
+
+  // Effect 3: filterValues 变化时，more 按钮 badge 可能变化，需要重新计算
+  useEffect(function () {
+    if (!containerRef.current || cachedWidths.current.length === 0) return;
+    var count = calculateRef.current(containerRef.current.offsetWidth);
+    setVisibleCount(function (prev) {
+      return prev === count ? prev : count;
+    });
+  }, [filterValues]);
+
+  // Effect 4: 监听子元素的宽度变化（如筛选值变化导致按钮变宽），
+  // 更新缓存宽度并重新计算可见数量。
+  // 依赖 visibleCount 以便在显隐切换后重新查询 DOM 元素。
+  useEffect(function () {
+    if (!containerRef.current || isMeasuring) return;
+    var el = containerRef.current;
+    var items = el.querySelectorAll('[data-filter-item]');
+    if (items.length === 0) return;
+    var ro = new ResizeObserver(function () {
+      var widthChanged = false;
+      items.forEach(function (item) {
+        var idx = Number(item.dataset.filterItem);
+        if (isNaN(idx)) return;
+        var w = item.offsetWidth;
+        if (w > 0 && Math.abs(w - (cachedWidths.current[idx] || 0)) > 1) {
+          cachedWidths.current[idx] = w;
+          widthChanged = true;
+        }
+      });
+      if (widthChanged) {
+        var count = calculateRef.current(el.offsetWidth);
+        setVisibleCount(function (prev) {
+          return prev === count ? prev : count;
+        });
+      }
+    });
+    items.forEach(function (item) {
+      return ro.observe(item);
+    });
+    return function () {
+      return ro.disconnect();
+    };
+  }, [isMeasuring, visibleCount]);
+
+  // --- 派生状态 ---
+  var visibleIndexSet = useMemo(function () {
+    if (visibleCount === null) return null;
+    return new Set(normalCollapsibleItems.slice(0, visibleCount).map(function (item) {
+      return item.index;
+    }));
+  }, [visibleCount, normalCollapsibleItems]);
+  var hiddenCollapsibleItems = useMemo(function () {
+    if (!visibleIndexSet) return [];
+    return normalCollapsibleItems.filter(function (item) {
+      return !visibleIndexSet.has(item.index);
+    });
+  }, [visibleIndexSet, normalCollapsibleItems]);
+  var allHiddenItems = useMemo(function () {
+    return [].concat(_toConsumableArray(alwaysCollapseItems), _toConsumableArray(hiddenCollapsibleItems));
+  }, [alwaysCollapseItems, hiddenCollapsibleItems]);
+
+  // --- 值管理 ---
+  var updateFilterValue = useCallback(function (id, _filterLabel, value, options, componentName) {
+    setFilterValues(function (prev) {
+      var isEmpty = value === undefined || value === null || value === '' || componentName === 'switch' && value === false || Array.isArray(value) && value.length === 0;
+      if (isEmpty) {
+        var filtered = prev.filter(function (item) {
+          return item.id !== id;
+        });
+        return filtered.length === prev.length ? prev : filtered;
+      }
+      var existingIndex = prev.findIndex(function (item) {
+        return item.id === id;
+      });
+      if (existingIndex >= 0) {
+        var existing = prev[existingIndex];
+        var optionsEqual = existing.options === options || existing.options === undefined && options === undefined || existing.options !== undefined && options !== undefined && JSON.stringify(existing.options) === JSON.stringify(options);
+        if (existing.value === value && optionsEqual && existing.componentName === componentName && existing.label === _filterLabel) {
+          return prev;
+        }
+        var newValues = _toConsumableArray(prev);
+        newValues[existingIndex] = {
+          id: id,
+          label: _filterLabel,
+          value: value,
+          options: options,
+          componentName: componentName
+        };
+        return newValues;
+      }
+      return [].concat(_toConsumableArray(prev), [{
+        id: id,
+        label: _filterLabel,
+        value: value,
+        options: options,
+        componentName: componentName
+      }]);
+    });
+  }, []);
+  var handleClearAll = function handleClearAll() {
+    allHiddenItems.forEach(function (item) {
+      if ( /*#__PURE__*/isValidElement(item.child)) {
+        var childProps = item.child.props;
+        if (childProps.children && /*#__PURE__*/isValidElement(childProps.children)) {
+          var _innerChildProps$onCh;
+          var innerChildProps = childProps.children.props;
+          (_innerChildProps$onCh = innerChildProps.onChange) === null || _innerChildProps$onCh === void 0 || _innerChildProps$onCh.call(innerChildProps, undefined);
+        } else {
+          var _childProps$onChange;
+          (_childProps$onChange = childProps.onChange) === null || _childProps$onChange === void 0 || _childProps$onChange.call(childProps, undefined);
+        }
+      }
+    });
+    setFilterValues([]);
+    onClearAll === null || onClearAll === void 0 || onClearAll();
+  };
+
+  // --- 渲染 FilterWrap（收起的筛选项） ---
+  var renderHiddenChildren = function renderHiddenChildren() {
+    if (allHiddenItems.length === 0) return null;
+    return /*#__PURE__*/_jsx(FilterProvider, {
+      isCollapsed: true,
+      filterValues: filterValues,
+      updateFilterValue: updateFilterValue,
+      children: /*#__PURE__*/_jsx(FilterWrap, {
+        collapsed: true,
+        filterButtonRef: filterButtonRef,
+        icon: icon,
+        label: filterLabel,
+        extra: extra,
+        onClearAll: handleClearAll,
+        showCount: showCount,
+        footer: showActions && /*#__PURE__*/_jsxs(Flex, {
+          justify: "space-between",
+          children: [onApply && /*#__PURE__*/_jsx(Button, {
+            type: "primary",
+            size: "small",
+            onClick: function onClick() {
+              var _filterButtonRef$curr;
+              onApply === null || onApply === void 0 || onApply();
+              (_filterButtonRef$curr = filterButtonRef.current) === null || _filterButtonRef$curr === void 0 || _filterButtonRef$curr.closePopover();
+            },
+            children: filterLocale === null || filterLocale === void 0 ? void 0 : filterLocale.apply
+          }), onClearAll && /*#__PURE__*/_jsx(Button, {
+            type: "link",
+            size: "small",
+            onClick: handleClearAll,
+            children: filterLocale === null || filterLocale === void 0 ? void 0 : filterLocale.clearAll
+          })]
+        }),
+        children: allHiddenItems.map(function (item, index) {
+          if ( /*#__PURE__*/isValidElement(item.child)) {
+            var stableKey = item.child.key || "responsive-filter-child-".concat(index);
+            return /*#__PURE__*/_jsx(React.Fragment, {
+              children: item.child
+            }, stableKey);
+          }
+          return item.child;
+        })
+      })
+    });
+  };
+
+  // --- 渲染子元素 ---
+  // 所有子元素始终保持在 Flex 中的稳定位置（FilterProvider + div 包裹 + 稳定 key），
+  // 通过 CSS display 控制显隐，避免在可见/折叠间切换时卸载重挂载导致表单值丢失。
+  // FilterProvider 使隐藏的原始组件能直接感知 isCollapsed 并上报值，无需依赖 Popover 中的克隆。
+  var renderChildren = function renderChildren() {
+    var elements = [];
+    var filterWrapInserted = false;
+    var collapsibleIdx = 0;
+    childrenArray.forEach(function (child, index) {
+      var info = childInfo[index];
+      var stableKey = child.key || "filter-item-".concat(index);
+      var display;
+      var isHidden = false;
+      if (isMeasuring) {
+        display = 'inline-flex';
+      } else if (!info.isCollapsible) {
+        display = undefined;
+      } else if (info.isAlwaysCollapse) {
+        display = 'none';
+        isHidden = true;
+      } else {
+        var isVisible = collapsibleIdx < visibleCount;
+        display = isVisible ? undefined : 'none';
+        isHidden = !isVisible;
+        collapsibleIdx++;
+      }
+      elements.push( /*#__PURE__*/_jsx(FilterProvider, {
+        isCollapsed: !isMeasuring && isHidden,
+        filterValues: filterValues,
+        updateFilterValue: updateFilterValue,
+        children: /*#__PURE__*/_jsx("div", {
+          "data-filter-item": index,
+          style: {
+            display: display,
+            flexShrink: 0
+          },
+          children: child
+        })
+      }, stableKey));
+      if (!isMeasuring && isHidden && !filterWrapInserted && allHiddenItems.length > 0) {
+        filterWrapInserted = true;
+        elements.push( /*#__PURE__*/_jsx(React.Fragment, {
+          children: renderHiddenChildren()
+        }, "filter-wrap"));
+      }
+    });
+    if (!isMeasuring && !filterWrapInserted && allHiddenItems.length > 0) {
+      elements.push( /*#__PURE__*/_jsx(React.Fragment, {
+        children: renderHiddenChildren()
+      }, "filter-wrap"));
+    }
+    return elements;
+  };
+  return /*#__PURE__*/_jsxs("div", {
+    ref: containerRef,
+    className: "responsive-filter-group",
+    style: _objectSpread({
+      flex: '1 1 auto',
+      minWidth: 0,
+      position: 'relative',
+      overflow: 'hidden',
+      visibility: isMeasuring ? 'hidden' : undefined
+    }, style),
+    children: [/*#__PURE__*/_jsx("div", {
+      ref: moreButtonMeasureRef,
+      style: {
+        position: 'absolute',
+        visibility: 'hidden',
+        pointerEvents: 'none',
+        top: -9999,
+        left: -9999,
+        display: 'inline-flex'
+      },
+      children: /*#__PURE__*/_jsx(FilterProvider, {
+        isCollapsed: true,
+        filterValues: filterValues,
+        updateFilterValue: updateFilterValue,
+        children: /*#__PURE__*/_jsx(FilterWrap, {
+          collapsed: true,
+          icon: icon,
+          label: filterLabel,
+          showCount: showCount,
+          onClearAll: handleClearAll,
+          children: /*#__PURE__*/_jsx("div", {})
+        })
+      })
+    }), /*#__PURE__*/_jsx(Flex, {
+      gap: gap,
+      align: "center",
+      wrap: "nowrap",
+      children: renderChildren()
+    })]
+  });
+};
+export default ResponsiveFilterGroup;

package/es/filter/components/WrappedTagsDisplay.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+export interface TagItem {
+    label: ReactNode;
+    value: string;
+}
+export interface WrappedTagsDisplayProps {
+    /** 选中的标签列表 */
+    tags: TagItem[];
+    /** 最多显示的标签数量，默认为 2 */
+    maxVisibleTags?: number;
+    /** 移除标签的回调 */
+    onRemove?: (value: string) => void;
+    /** 标签的最大宽度，默认为 80 */
+    tagMaxWidth?: number;
+}
+/**
+ * Wrapped 模式下的 Tag 展示组件
+ * 用于 FilterCheckbox、FilterCascader 等多选组件在 wrapped 模式下展示选中值
+ */
+declare const WrappedTagsDisplay: React.FC<WrappedTagsDisplayProps>;
+export default WrappedTagsDisplay;

package/es/filter/components/WrappedTagsDisplay.js

@@ -0,0 +1,80 @@
+"use client";
+import React, { useContext } from 'react';
+import { Flex } from 'antd';
+import Tag from "../../tag";
+import Tooltip from "../../tooltip";
+import theme from "../../theme";
+import ConfigProvider from "../../config-provider";
+import enUS from "../../locale/en-US";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Wrapped 模式下的 Tag 展示组件
+ * 用于 FilterCheckbox、FilterCascader 等多选组件在 wrapped 模式下展示选中值
+ */
+var WrappedTagsDisplay = function WrappedTagsDisplay(_ref) {
+  var tags = _ref.tags,
+    _ref$maxVisibleTags = _ref.maxVisibleTags,
+    maxVisibleTags = _ref$maxVisibleTags === void 0 ? 2 : _ref$maxVisibleTags,
+    onRemove = _ref.onRemove,
+    _ref$tagMaxWidth = _ref.tagMaxWidth,
+    tagMaxWidth = _ref$tagMaxWidth === void 0 ? 80 : _ref$tagMaxWidth;
+  var _theme$useToken = theme.useToken(),
+    token = _theme$useToken.token;
+  var _useContext = useContext(ConfigProvider.ConfigContext),
+    contextLocale = _useContext.locale;
+  var filterLocale = (contextLocale === null || contextLocale === void 0 ? void 0 : contextLocale.Filter) || enUS.Filter;
+  var hasValue = tags.length > 0;
+  var visibleTags = tags.slice(0, maxVisibleTags);
+  var hiddenTags = tags.slice(maxVisibleTags);
+  var hiddenCount = hiddenTags.length;
+  if (!hasValue) {
+    return /*#__PURE__*/_jsx("span", {
+      style: {
+        color: token.colorTextPlaceholder
+      },
+      children: filterLocale === null || filterLocale === void 0 ? void 0 : filterLocale.pleaseSelect
+    });
+  }
+  return /*#__PURE__*/_jsxs(Flex, {
+    align: "center",
+    style: {
+      overflow: 'hidden',
+      flex: 1
+    },
+    children: [visibleTags.map(function (item) {
+      return /*#__PURE__*/_jsx(Tag, {
+        closable: !!onRemove,
+        onClose: function onClose(e) {
+          e.preventDefault();
+          e.stopPropagation();
+          onRemove === null || onRemove === void 0 || onRemove(item.value);
+        },
+        style: {
+          maxWidth: tagMaxWidth,
+          marginRight: 4
+        },
+        children: item.label
+      }, item.value);
+    }), hiddenCount > 0 && /*#__PURE__*/_jsx(Tooltip, {
+      title: hiddenTags.map(function (item) {
+        return /*#__PURE__*/_jsx(Tag, {
+          closable: !!onRemove,
+          onClose: function onClose(e) {
+            e.preventDefault();
+            e.stopPropagation();
+            onRemove === null || onRemove === void 0 || onRemove(item.value);
+          },
+          children: item.label
+        }, item.value);
+      }),
+      children: /*#__PURE__*/_jsx(Tag, {
+        style: {
+          margin: 0
+        },
+        children: ".."
+      })
+    })]
+  });
+};
+export default WrappedTagsDisplay;

package/es/filter/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useControlledState } from './useControlledState';
+export { useFilterCollapsed } from './useFilterCollapsed';
+export { useFilterTooltip } from './useFilterTooltip';
+export type { UseFilterTooltipOptions, UseFilterTooltipReturn } from './useFilterTooltip';

package/es/filter/hooks/index.js

@@ -0,0 +1,3 @@
+export { useControlledState } from "./useControlledState";
+export { useFilterCollapsed } from "./useFilterCollapsed";
+export { useFilterTooltip } from "./useFilterTooltip";

package/es/filter/hooks/useControlledState.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 处理受控/非受控组件状态的通用 Hook
+ * @param value 外部传入的受控值
+ * @param defaultValue 默认值
+ * @param onChange 值变化时的回调
+ * @returns [currentValue, setValue, isControlled]
+ */
+export declare function useControlledState<T>(value: T | undefined, defaultValue: T, onChange?: (value: T) => void): [T, (value: T) => void, boolean];
+export default useControlledState;

package/es/filter/hooks/useControlledState.js

@@ -0,0 +1,37 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useState } from 'react';
+
+/**
+ * 处理受控/非受控组件状态的通用 Hook
+ * @param value 外部传入的受控值
+ * @param defaultValue 默认值
+ * @param onChange 值变化时的回调
+ * @returns [currentValue, setValue, isControlled]
+ */
+export function useControlledState(value, defaultValue, onChange) {
+  var isControlled = value !== undefined;
+  var _useState = useState(defaultValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    internalValue = _useState2[0],
+    setInternalValue = _useState2[1];
+
+  // 使用受控值或内部值
+  var currentValue = isControlled ? value : internalValue;
+
+  // 统一的 setValue 方法
+  var setValue = useCallback(function (newValue) {
+    // 如果是非受控组件，更新内部状态
+    if (!isControlled) {
+      setInternalValue(newValue);
+    }
+    // 总是调用 onChange 回调
+    onChange === null || onChange === void 0 || onChange(newValue);
+  }, [isControlled, onChange]);
+  return [currentValue, setValue, isControlled];
+}
+export default useControlledState;

package/es/filter/hooks/useFilterCollapsed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 判断 Filter 组件是否处于折叠模式
+ * 支持通过 context 或 prop 来判断
+ * @param isCollapsedProp 通过 prop 传入的 _isCollapsed 值
+ * @returns 是否处于折叠模式
+ */
+export declare function useFilterCollapsed(isCollapsedProp?: boolean): boolean;
+export default useFilterCollapsed;

package/es/filter/hooks/useFilterCollapsed.js

@@ -0,0 +1,15 @@
+import { useFilterContext } from "../FilterContext";
+
+/**
+ * 判断 Filter 组件是否处于折叠模式
+ * 支持通过 context 或 prop 来判断
+ * @param isCollapsedProp 通过 prop 传入的 _isCollapsed 值
+ * @returns 是否处于折叠模式
+ */
+export function useFilterCollapsed() {
+  var isCollapsedProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var _useFilterContext = useFilterContext(),
+    isCollapsedFromContext = _useFilterContext.isCollapsed;
+  return isCollapsedFromContext || isCollapsedProp;
+}
+export default useFilterCollapsed;