@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/table/features/filter/FilterDropdown.js

@@ -0,0 +1,494 @@
+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); }
+var _excluded = ["dropdownRender"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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); }
+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 _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 _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 _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 _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 _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; }
+import * as React from 'react';
+import FilterFilled from '@ant-design/icons/FilterFilled';
+import { isEqual, mergeProps } from "../../../_util/rcUtil";
+import { clsx } from 'clsx';
+import { useSyncState } from "../../../_util/hooks/useSyncState";
+import { isFunction, isNumber } from "../../../_util/is";
+import { devUseWarning } from "../../../_util/warning";
+import Button from 'antd/lib/button';
+import Checkbox from 'antd/lib/checkbox';
+import { ConfigContext } from 'antd/lib/config-provider';
+import Dropdown from 'antd/lib/dropdown';
+import Empty from 'antd/lib/empty';
+import Menu from 'antd/lib/menu';
+import OverrideProvider from 'antd/lib/menu/OverrideContext';
+import Radio from 'antd/lib/radio';
+import Tree from 'antd/lib/tree';
+import TableMeasureRowContext from "../../TableMeasureRowContext";
+import FilterSearch from "./FilterSearch";
+import FilterDropdownMenuWrapper from "./FilterWrapper";
+export function flattenKeys(filters) {
+  var keys = [];
+  (filters || []).forEach(function (_ref) {
+    var value = _ref.value,
+      children = _ref.children;
+    keys.push(value);
+    if (children) {
+      keys = [].concat(_toConsumableArray(keys), _toConsumableArray(flattenKeys(children)));
+    }
+  });
+  return keys;
+}
+function hasSubMenu(filters) {
+  return filters.some(function (_ref2) {
+    var children = _ref2.children;
+    return children;
+  });
+}
+var searchValueMatched = function searchValueMatched(normalizedSearchValue, text) {
+  if (typeof text === 'string' || isNumber(text)) {
+    return text.toString().toLowerCase().includes(normalizedSearchValue);
+  }
+  return false;
+};
+var renderFilterItems = function renderFilterItems(options) {
+  var filters = options.filters,
+    prefixCls = options.prefixCls,
+    filteredKeys = options.filteredKeys,
+    filterMultiple = options.filterMultiple,
+    searchValue = options.searchValue,
+    normalizedSearchValue = options.normalizedSearchValue,
+    filterSearch = options.filterSearch;
+  return filters.map(function (filter, index) {
+    var key = String(filter.value);
+    if (filter.children) {
+      return {
+        key: key || index,
+        label: filter.text,
+        popupClassName: "".concat(prefixCls, "-dropdown-submenu"),
+        children: renderFilterItems({
+          filters: filter.children,
+          prefixCls: prefixCls,
+          filteredKeys: filteredKeys,
+          filterMultiple: filterMultiple,
+          searchValue: searchValue,
+          normalizedSearchValue: normalizedSearchValue,
+          filterSearch: filterSearch
+        })
+      };
+    }
+    var Component = filterMultiple ? Checkbox : Radio;
+    var item = {
+      key: filter.value !== undefined ? key : index,
+      label: /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Component, {
+        checked: filteredKeys.includes(key)
+      }), /*#__PURE__*/React.createElement("span", null, filter.text))
+    };
+    if (normalizedSearchValue) {
+      if (isFunction(filterSearch)) {
+        return filterSearch(normalizedSearchValue, filter) ? item : null;
+      }
+      return searchValueMatched(normalizedSearchValue, filter.text) ? item : null;
+    }
+    return item;
+  });
+};
+function wrapStringListType(keys) {
+  return keys || [];
+}
+var FilterDropdown = function FilterDropdown(props) {
+  var _filterState$filtered, _ref5, _filterDropdownProps$2;
+  var tablePrefixCls = props.tablePrefixCls,
+    prefixCls = props.prefixCls,
+    column = props.column,
+    dropdownPrefixCls = props.dropdownPrefixCls,
+    columnKey = props.columnKey,
+    filterOnClose = props.filterOnClose,
+    filterMultiple = props.filterMultiple,
+    _props$filterMode = props.filterMode,
+    filterMode = _props$filterMode === void 0 ? 'menu' : _props$filterMode,
+    _props$filterSearch = props.filterSearch,
+    filterSearch = _props$filterSearch === void 0 ? false : _props$filterSearch,
+    filterState = props.filterState,
+    triggerFilter = props.triggerFilter,
+    locale = props.locale,
+    children = props.children,
+    getPopupContainer = props.getPopupContainer;
+  var filterResetToDefaultFilteredValue = column.filterResetToDefaultFilteredValue,
+    defaultFilteredValue = column.defaultFilteredValue,
+    _column$filterDropdow = column.filterDropdownProps,
+    filterDropdownProps = _column$filterDropdow === void 0 ? {} : _column$filterDropdow,
+    filterDropdownOpen = column.filterDropdownOpen,
+    onFilterDropdownOpenChange = column.onFilterDropdownOpenChange;
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    visible = _React$useState2[0],
+    setVisible = _React$useState2[1];
+  var inMeasureRow = React.useContext(TableMeasureRowContext);
+  var filtered = !!(filterState && ((_filterState$filtered = filterState.filteredKeys) !== null && _filterState$filtered !== void 0 && _filterState$filtered.length || filterState.forceFiltered));
+  var triggerVisible = function triggerVisible(newVisible) {
+    var _filterDropdownProps$;
+    setVisible(newVisible);
+    (_filterDropdownProps$ = filterDropdownProps.onOpenChange) === null || _filterDropdownProps$ === void 0 || _filterDropdownProps$.call(filterDropdownProps, newVisible);
+    onFilterDropdownOpenChange === null || onFilterDropdownOpenChange === void 0 || onFilterDropdownOpenChange(newVisible);
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    var warning = devUseWarning('Table');
+    var deprecatedList = [['filterDropdownOpen', 'filterDropdownProps.open'], ['onFilterDropdownOpenChange', 'filterDropdownProps.onOpenChange']];
+    deprecatedList.forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        deprecatedName = _ref4[0],
+        newName = _ref4[1];
+      warning.deprecated(!(deprecatedName in column), deprecatedName, newName);
+    });
+    warning.deprecated(!('filterCheckall' in locale), 'filterCheckall', 'locale.filterCheckAll');
+  }
+  var mergedVisible = (_ref5 = (_filterDropdownProps$2 = filterDropdownProps.open) !== null && _filterDropdownProps$2 !== void 0 ? _filterDropdownProps$2 : filterDropdownOpen) !== null && _ref5 !== void 0 ? _ref5 : visible;
+  var propFilteredKeys = filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys;
+  var _useSyncState = useSyncState(wrapStringListType(propFilteredKeys)),
+    _useSyncState2 = _slicedToArray(_useSyncState, 2),
+    getFilteredKeysSync = _useSyncState2[0],
+    setFilteredKeysSync = _useSyncState2[1];
+  var onSelectKeys = function onSelectKeys(_ref6) {
+    var selectedKeys = _ref6.selectedKeys;
+    setFilteredKeysSync(selectedKeys);
+  };
+  var onCheck = function onCheck(keys, _ref7) {
+    var node = _ref7.node,
+      checked = _ref7.checked;
+    if (!filterMultiple) {
+      onSelectKeys({
+        selectedKeys: checked && node.key ? [node.key] : []
+      });
+    } else {
+      onSelectKeys({
+        selectedKeys: keys
+      });
+    }
+  };
+  React.useEffect(function () {
+    if (!visible) {
+      return;
+    }
+    onSelectKeys({
+      selectedKeys: wrapStringListType(propFilteredKeys)
+    });
+  }, [propFilteredKeys]);
+  var _React$useState3 = React.useState([]),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    openKeys = _React$useState4[0],
+    setOpenKeys = _React$useState4[1];
+  var onOpenChange = function onOpenChange(keys) {
+    setOpenKeys(keys);
+  };
+  var _React$useState5 = React.useState(''),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    searchValue = _React$useState6[0],
+    setSearchValue = _React$useState6[1];
+  var normalizedSearchValue = React.useMemo(function () {
+    return searchValue.trim().toLowerCase();
+  }, [searchValue]);
+  var onSearch = function onSearch(e) {
+    var value = e.target.value;
+    setSearchValue(value);
+  };
+  React.useEffect(function () {
+    if (!visible) {
+      setSearchValue('');
+    }
+  }, [visible]);
+  var internalTriggerFilter = function internalTriggerFilter(keys) {
+    var mergedKeys = keys !== null && keys !== void 0 && keys.length ? keys : null;
+    if (mergedKeys === null && (!filterState || !filterState.filteredKeys)) {
+      return null;
+    }
+    if (isEqual(mergedKeys, filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys, true)) {
+      return null;
+    }
+    triggerFilter({
+      column: column,
+      key: columnKey,
+      filteredKeys: mergedKeys
+    });
+  };
+  var onConfirm = function onConfirm() {
+    triggerVisible(false);
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  var onReset = function onReset() {
+    var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        confirm: false,
+        closeDropdown: false
+      },
+      confirm = _ref8.confirm,
+      closeDropdown = _ref8.closeDropdown;
+    if (confirm) {
+      internalTriggerFilter([]);
+    }
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    setSearchValue('');
+    if (filterResetToDefaultFilteredValue) {
+      setFilteredKeysSync((defaultFilteredValue || []).map(String));
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  var doFilter = function doFilter() {
+    var _ref9 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        closeDropdown: true
+      },
+      closeDropdown = _ref9.closeDropdown;
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  var onVisibleChange = function onVisibleChange(newVisible) {
+    if (newVisible && propFilteredKeys !== undefined) {
+      setFilteredKeysSync(wrapStringListType(propFilteredKeys));
+    }
+    triggerVisible(newVisible);
+    if (!newVisible && !column.filterDropdown && filterOnClose) {
+      onConfirm();
+    }
+  };
+  var dropdownMenuClass = clsx(_defineProperty({}, "".concat(dropdownPrefixCls, "-menu-without-submenu"), !hasSubMenu(column.filters || [])));
+  var onCheckAll = function onCheckAll(e) {
+    if (e.target.checked) {
+      var allFilterKeys = flattenKeys(column === null || column === void 0 ? void 0 : column.filters).map(String);
+      setFilteredKeysSync(allFilterKeys);
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  var getTreeData = function getTreeData(_ref10) {
+    var filters = _ref10.filters;
+    return (filters || []).map(function (filter, index) {
+      var key = String(filter.value);
+      var item = {
+        title: filter.text,
+        key: filter.value !== undefined ? key : String(index)
+      };
+      if (filter.children) {
+        item.children = getTreeData({
+          filters: filter.children
+        });
+      }
+      return item;
+    });
+  };
+  var getFilterData = function getFilterData(node) {
+    var _node$children;
+    return _objectSpread(_objectSpread({}, node), {}, {
+      text: node.title,
+      value: node.key,
+      children: ((_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.map(getFilterData)) || []
+    });
+  };
+  var dropdownContent;
+  var _React$useContext = React.useContext(ConfigContext),
+    direction = _React$useContext.direction,
+    renderEmpty = _React$useContext.renderEmpty;
+  if (isFunction(column.filterDropdown)) {
+    dropdownContent = column.filterDropdown({
+      prefixCls: "".concat(dropdownPrefixCls, "-custom"),
+      setSelectedKeys: function setSelectedKeys(selectedKeys) {
+        return onSelectKeys({
+          selectedKeys: selectedKeys
+        });
+      },
+      selectedKeys: getFilteredKeysSync(),
+      confirm: doFilter,
+      clearFilters: onReset,
+      filters: column.filters,
+      visible: mergedVisible,
+      close: function close() {
+        triggerVisible(false);
+      }
+    });
+  } else if (column.filterDropdown) {
+    dropdownContent = column.filterDropdown;
+  } else {
+    var selectedKeys = getFilteredKeysSync() || [];
+    var getFilterComponent = function getFilterComponent() {
+      var _renderEmpty;
+      var empty = (_renderEmpty = renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Table.filter')) !== null && _renderEmpty !== void 0 ? _renderEmpty : /*#__PURE__*/React.createElement(Empty, {
+        image: Empty.PRESENTED_IMAGE_SIMPLE,
+        description: locale.filterEmptyText,
+        style: {
+          margin: 0,
+          padding: '16px 0'
+        }
+      });
+      if ((column.filters || []).length === 0) {
+        return empty;
+      }
+      if (filterMode === 'tree') {
+        var _locale$filterCheckal;
+        return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterSearch, {
+          filterSearch: filterSearch,
+          value: searchValue,
+          onChange: onSearch,
+          tablePrefixCls: tablePrefixCls,
+          locale: locale
+        }), /*#__PURE__*/React.createElement("div", {
+          className: "".concat(tablePrefixCls, "-filter-dropdown-tree")
+        }, filterMultiple ? /*#__PURE__*/React.createElement(Checkbox, {
+          checked: selectedKeys.length === flattenKeys(column.filters).length,
+          indeterminate: selectedKeys.length > 0 && selectedKeys.length < flattenKeys(column.filters).length,
+          className: "".concat(tablePrefixCls, "-filter-dropdown-checkall"),
+          onChange: onCheckAll
+        }, (_locale$filterCheckal = locale === null || locale === void 0 ? void 0 : locale.filterCheckall) !== null && _locale$filterCheckal !== void 0 ? _locale$filterCheckal : locale === null || locale === void 0 ? void 0 : locale.filterCheckAll) : null, /*#__PURE__*/React.createElement(Tree, {
+          checkable: true,
+          selectable: false,
+          blockNode: true,
+          multiple: filterMultiple,
+          checkStrictly: !filterMultiple,
+          className: "".concat(dropdownPrefixCls, "-menu"),
+          onCheck: onCheck,
+          checkedKeys: selectedKeys,
+          selectedKeys: selectedKeys,
+          showIcon: false,
+          treeData: getTreeData({
+            filters: column.filters
+          }),
+          autoExpandParent: true,
+          defaultExpandAll: true,
+          filterTreeNode: normalizedSearchValue ? function (node) {
+            if (isFunction(filterSearch)) {
+              return filterSearch(searchValue, getFilterData(node));
+            }
+            return searchValueMatched(normalizedSearchValue, node.title);
+          } : undefined
+        })));
+      }
+      var items = renderFilterItems({
+        filters: column.filters || [],
+        filterSearch: filterSearch,
+        prefixCls: prefixCls,
+        filteredKeys: getFilteredKeysSync(),
+        filterMultiple: filterMultiple,
+        searchValue: searchValue,
+        normalizedSearchValue: normalizedSearchValue
+      });
+      var isEmpty = items.every(function (item) {
+        return item === null;
+      });
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FilterSearch, {
+        filterSearch: filterSearch,
+        value: searchValue,
+        onChange: onSearch,
+        tablePrefixCls: tablePrefixCls,
+        locale: locale
+      }), isEmpty ? empty : /*#__PURE__*/React.createElement(Menu, {
+        selectable: true,
+        multiple: filterMultiple,
+        prefixCls: "".concat(dropdownPrefixCls, "-menu"),
+        className: dropdownMenuClass,
+        onSelect: onSelectKeys,
+        onDeselect: onSelectKeys,
+        selectedKeys: selectedKeys,
+        getPopupContainer: getPopupContainer,
+        openKeys: openKeys,
+        onOpenChange: onOpenChange,
+        items: items
+      }));
+    };
+    var getResetDisabled = function getResetDisabled() {
+      if (filterResetToDefaultFilteredValue) {
+        return isEqual((defaultFilteredValue || []).map(String), selectedKeys, true);
+      }
+      return selectedKeys.length === 0;
+    };
+    dropdownContent = /*#__PURE__*/React.createElement(React.Fragment, null, getFilterComponent(), /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-dropdown-btns")
+    }, /*#__PURE__*/React.createElement(Button, {
+      type: "link",
+      size: "small",
+      disabled: getResetDisabled(),
+      onClick: function onClick() {
+        return onReset();
+      }
+    }, locale.filterReset), /*#__PURE__*/React.createElement(Button, {
+      type: "primary",
+      size: "small",
+      onClick: onConfirm
+    }, locale.filterConfirm)));
+  }
+  if (column.filterDropdown) {
+    dropdownContent = /*#__PURE__*/React.createElement(OverrideProvider, {
+      selectable: undefined
+    }, dropdownContent);
+  }
+  dropdownContent = /*#__PURE__*/React.createElement(FilterDropdownMenuWrapper, {
+    className: "".concat(prefixCls, "-dropdown")
+  }, dropdownContent);
+  var getDropdownTrigger = function getDropdownTrigger() {
+    var filterIcon;
+    if (isFunction(column.filterIcon)) {
+      filterIcon = column.filterIcon(filtered);
+    } else if (column.filterIcon) {
+      filterIcon = column.filterIcon;
+    } else {
+      filterIcon = /*#__PURE__*/React.createElement(FilterFilled, null);
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      role: "button",
+      tabIndex: -1,
+      className: clsx("".concat(prefixCls, "-trigger"), {
+        active: filtered
+      }),
+      onClick: function onClick(e) {
+        e.stopPropagation();
+      }
+    }, filterIcon);
+  };
+  var triggerNode = getDropdownTrigger();
+  if (inMeasureRow) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-column")
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(tablePrefixCls, "-column-title")
+    }, children), triggerNode);
+  }
+
+  // antd v4.24+ 废弃 overlay，改用 menu + dropdownRender
+  var _ref11 = filterDropdownProps,
+    userDropdownRender = _ref11.dropdownRender,
+    restFilterDropdownProps = _objectWithoutProperties(_ref11, _excluded);
+  var mergedDropdownProps = mergeProps({
+    trigger: ['click'],
+    placement: direction === 'rtl' ? 'bottomLeft' : 'bottomRight',
+    children: triggerNode,
+    getPopupContainer: getPopupContainer
+  }, _objectSpread(_objectSpread({}, restFilterDropdownProps), {}, {
+    open: mergedVisible,
+    onOpenChange: onVisibleChange,
+    menu: {
+      items: []
+    },
+    dropdownRender: function dropdownRender() {
+      if (isFunction(userDropdownRender)) {
+        return userDropdownRender(dropdownContent);
+      }
+      return dropdownContent;
+    }
+  }));
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-column")
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(tablePrefixCls, "-column-title")
+  }, children), /*#__PURE__*/React.createElement(Dropdown, mergedDropdownProps));
+};
+export default FilterDropdown;

package/es/table/features/filter/FilterSearch.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { AnyObject } from '../../../_util/type';
+import type { FilterSearchType, TableLocale } from '../../interface';
+interface FilterSearchProps<RecordType = AnyObject> {
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    filterSearch: FilterSearchType<RecordType>;
+    tablePrefixCls: string;
+    locale: TableLocale;
+}
+declare const FilterSearch: <RecordType extends AnyObject = AnyObject>(props: FilterSearchProps<RecordType>) => React.JSX.Element | null;
+export default FilterSearch;

package/es/table/features/filter/FilterSearch.js

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import SearchOutlined from '@ant-design/icons/SearchOutlined';
+import Input from 'antd/lib/input';
+var FilterSearch = function FilterSearch(props) {
+  var value = props.value,
+    filterSearch = props.filterSearch,
+    tablePrefixCls = props.tablePrefixCls,
+    locale = props.locale,
+    onChange = props.onChange;
+  if (!filterSearch) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(tablePrefixCls, "-filter-dropdown-search")
+  }, /*#__PURE__*/React.createElement(Input, {
+    prefix: /*#__PURE__*/React.createElement(SearchOutlined, null),
+    placeholder: locale.filterSearchPlaceholder,
+    onChange: onChange,
+    value: value,
+    htmlSize: 1,
+    className: "".concat(tablePrefixCls, "-filter-dropdown-search-input")
+  }));
+};
+export default FilterSearch;

package/es/table/features/filter/FilterWrapper.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface FilterDropdownMenuWrapperProps {
+    className?: string;
+}
+declare const FilterDropdownMenuWrapper: React.ForwardRefExoticComponent<FilterDropdownMenuWrapperProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default FilterDropdownMenuWrapper;

package/es/table/features/filter/FilterWrapper.js

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { KeyCode } from "../../../_util/rcUtil";
+var onKeyDown = function onKeyDown(event) {
+  var keyCode = event.keyCode;
+  if (keyCode === KeyCode.ENTER) {
+    event.stopPropagation();
+  }
+};
+var FilterDropdownMenuWrapper = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    },
+    onKeyDown: onKeyDown,
+    ref: ref,
+    role: "presentation"
+  }, props.children);
+});
+if (process.env.NODE_ENV !== 'production') {
+  FilterDropdownMenuWrapper.displayName = 'FilterDropdownMenuWrapper';
+}
+export default FilterDropdownMenuWrapper;

package/es/table/features/filter/index.d.ts

@@ -0,0 +1,4 @@
+export { default as FilterDropdown, flattenKeys } from './FilterDropdown';
+export { default as FilterSearch } from './FilterSearch';
+export { default as FilterWrapper } from './FilterWrapper';
+export { getFilterData, default as useFilter } from './useFilter';

package/es/table/features/filter/index.js

@@ -0,0 +1,4 @@
+export { default as FilterDropdown, flattenKeys } from "./FilterDropdown";
+export { default as FilterSearch } from "./FilterSearch";
+export { default as FilterWrapper } from "./FilterWrapper";
+export { getFilterData, default as useFilter } from "./useFilter";

package/es/table/features/filter/useFilter.d.ts

@@ -0,0 +1,22 @@
+import type { AnyObject } from '../../../_util/type';
+import type { ColumnsType, ColumnType, FilterKey, FilterValue, GetPopupContainer, Key, TableLocale, TransformColumns } from '../../interface';
+import { flattenKeys } from './FilterDropdown';
+export interface FilterState<RecordType = AnyObject> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    filteredKeys?: FilterKey;
+    forceFiltered?: boolean;
+}
+export declare const getFilterData: <RecordType extends AnyObject = AnyObject>(data: RecordType[], filterStates: FilterState<RecordType>[], childrenColumnName: string) => RecordType[];
+export interface FilterConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    mergedColumns: ColumnsType<RecordType>;
+    locale: TableLocale;
+    onFilterChange: (filters: Record<string, FilterValue | null>, filterStates: FilterState<RecordType>[]) => void;
+    getPopupContainer?: GetPopupContainer;
+    rootClassName?: string;
+}
+declare const useFilter: <RecordType extends AnyObject = AnyObject>(props: FilterConfig<RecordType>) => [TransformColumns<RecordType>, FilterState<RecordType>[], Record<string, FilterValue | null>];
+export { flattenKeys };
+export default useFilter;