add all frontend files

node_modules/antd/es/table/hooks/useContainerWidth.d.ts

@@ -0,0 +1 @@
+export default function useContainerWidth(prefixCls: string): (ele: HTMLElement, width: number) => number;

node_modules/antd/es/table/hooks/useContainerWidth.js

@@ -0,0 +1,14 @@
+export default function useContainerWidth(prefixCls) {
+  const getContainerWidth = (ele, width) => {
+    const container = ele.querySelector(`.${prefixCls}-container`);
+    let returnWidth = width;
+    if (container) {
+      const style = getComputedStyle(container);
+      const borderLeft = Number.parseInt(style.borderLeftWidth, 10);
+      const borderRight = Number.parseInt(style.borderRightWidth, 10);
+      returnWidth = width - borderLeft - borderRight;
+    }
+    return returnWidth;
+  };
+  return getContainerWidth;
+}

node_modules/antd/es/table/hooks/useFilter/FilterDropdown.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { AnyObject } from 'antd/es/_util/type';
+import type { FieldDataNode } from 'rc-tree';
+import type { FilterState } from '.';
+import type { ColumnFilterItem, ColumnType, FilterSearchType, FilterValue, GetPopupContainer, Key, TableLocale } from '../../interface';
+type FilterTreeDataNode = FieldDataNode<{
+    title: React.ReactNode;
+    key: string;
+}>;
+export declare function flattenKeys(filters?: ColumnFilterItem[]): FilterValue;
+export type TreeColumnFilterItem = ColumnFilterItem & FilterTreeDataNode;
+export interface FilterDropdownProps<RecordType = AnyObject> {
+    tablePrefixCls: string;
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    column: ColumnType<RecordType>;
+    filterState?: FilterState<RecordType>;
+    filterOnClose: boolean;
+    filterMultiple: boolean;
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem | TreeColumnFilterItem>;
+    columnKey: Key;
+    children: React.ReactNode;
+    triggerFilter: (filterState: FilterState<RecordType>) => void;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+    filterResetToDefaultFilteredValue?: boolean;
+    rootClassName?: string;
+}
+declare const FilterDropdown: <RecordType extends AnyObject = AnyObject>(props: FilterDropdownProps<RecordType>) => React.JSX.Element;
+export default FilterDropdown;

node_modules/antd/es/table/hooks/useFilter/FilterDropdown.js

@@ -0,0 +1,463 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import FilterFilled from "@ant-design/icons/es/icons/FilterFilled";
+import classNames from 'classnames';
+import isEqual from "rc-util/es/isEqual";
+import extendsObject from '../../../_util/extendsObject';
+import { useSyncState } from '../../../_util/hooks';
+import { devUseWarning } from '../../../_util/warning';
+import Button from '../../../button';
+import Checkbox from '../../../checkbox';
+import { ConfigContext } from '../../../config-provider/context';
+import Dropdown from '../../../dropdown';
+import Empty from '../../../empty';
+import Menu from '../../../menu';
+import { OverrideProvider } from '../../../menu/OverrideContext';
+import Radio from '../../../radio';
+import Tree from '../../../tree';
+import FilterSearch from './FilterSearch';
+import FilterDropdownMenuWrapper from './FilterWrapper';
+export function flattenKeys(filters) {
+  let keys = [];
+  (filters || []).forEach(({
+    value,
+    children
+  }) => {
+    keys.push(value);
+    if (children) {
+      keys = [].concat(_toConsumableArray(keys), _toConsumableArray(flattenKeys(children)));
+    }
+  });
+  return keys;
+}
+function hasSubMenu(filters) {
+  return filters.some(({
+    children
+  }) => children);
+}
+function searchValueMatched(searchValue, text) {
+  if (typeof text === 'string' || typeof text === 'number') {
+    return text === null || text === void 0 ? void 0 : text.toString().toLowerCase().includes(searchValue.trim().toLowerCase());
+  }
+  return false;
+}
+function renderFilterItems({
+  filters,
+  prefixCls,
+  filteredKeys,
+  filterMultiple,
+  searchValue,
+  filterSearch
+}) {
+  return filters.map((filter, index) => {
+    const key = String(filter.value);
+    if (filter.children) {
+      return {
+        key: key || index,
+        label: filter.text,
+        popupClassName: `${prefixCls}-dropdown-submenu`,
+        children: renderFilterItems({
+          filters: filter.children,
+          prefixCls,
+          filteredKeys,
+          filterMultiple,
+          searchValue,
+          filterSearch
+        })
+      };
+    }
+    const Component = filterMultiple ? Checkbox : Radio;
+    const 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 (searchValue.trim()) {
+      if (typeof filterSearch === 'function') {
+        return filterSearch(searchValue, filter) ? item : null;
+      }
+      return searchValueMatched(searchValue, filter.text) ? item : null;
+    }
+    return item;
+  });
+}
+function wrapStringListType(keys) {
+  return keys || [];
+}
+const FilterDropdown = props => {
+  var _a, _b, _c, _d;
+  const {
+    tablePrefixCls,
+    prefixCls,
+    column,
+    dropdownPrefixCls,
+    columnKey,
+    filterOnClose,
+    filterMultiple,
+    filterMode = 'menu',
+    filterSearch = false,
+    filterState,
+    triggerFilter,
+    locale,
+    children,
+    getPopupContainer,
+    rootClassName
+  } = props;
+  const {
+    filterResetToDefaultFilteredValue,
+    defaultFilteredValue,
+    filterDropdownProps = {},
+    // Deprecated
+    filterDropdownOpen,
+    filterDropdownVisible,
+    onFilterDropdownVisibleChange,
+    onFilterDropdownOpenChange
+  } = column;
+  const [visible, setVisible] = React.useState(false);
+  const filtered = !!(filterState && (((_a = filterState.filteredKeys) === null || _a === void 0 ? void 0 : _a.length) || filterState.forceFiltered));
+  const triggerVisible = newVisible => {
+    var _a;
+    setVisible(newVisible);
+    (_a = filterDropdownProps.onOpenChange) === null || _a === void 0 ? void 0 : _a.call(filterDropdownProps, newVisible);
+    // deprecated
+    onFilterDropdownOpenChange === null || onFilterDropdownOpenChange === void 0 ? void 0 : onFilterDropdownOpenChange(newVisible);
+    onFilterDropdownVisibleChange === null || onFilterDropdownVisibleChange === void 0 ? void 0 : onFilterDropdownVisibleChange(newVisible);
+  };
+  // =================Warning===================
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Table');
+    const deprecatedList = [['filterDropdownOpen', 'filterDropdownProps.open'], ['filterDropdownVisible', 'filterDropdownProps.open'], ['onFilterDropdownOpenChange', 'filterDropdownProps.onOpenChange'], ['onFilterDropdownVisibleChange', 'filterDropdownProps.onOpenChange']];
+    deprecatedList.forEach(([deprecatedName, newName]) => {
+      warning.deprecated(!(deprecatedName in column), deprecatedName, newName);
+    });
+    warning.deprecated(!('filterCheckall' in locale), 'filterCheckall', 'locale.filterCheckAll');
+  }
+  const mergedVisible = (_d = (_c = (_b = filterDropdownProps.open) !== null && _b !== void 0 ? _b : filterDropdownOpen) !== null && _c !== void 0 ? _c : filterDropdownVisible) !== null && _d !== void 0 ? _d : visible; // inner state
+  // ===================== Select Keys =====================
+  const propFilteredKeys = filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys;
+  const [getFilteredKeysSync, setFilteredKeysSync] = useSyncState(wrapStringListType(propFilteredKeys));
+  const onSelectKeys = ({
+    selectedKeys
+  }) => {
+    setFilteredKeysSync(selectedKeys);
+  };
+  const onCheck = (keys, {
+    node,
+    checked
+  }) => {
+    if (!filterMultiple) {
+      onSelectKeys({
+        selectedKeys: checked && node.key ? [node.key] : []
+      });
+    } else {
+      onSelectKeys({
+        selectedKeys: keys
+      });
+    }
+  };
+  React.useEffect(() => {
+    if (!visible) {
+      return;
+    }
+    onSelectKeys({
+      selectedKeys: wrapStringListType(propFilteredKeys)
+    });
+  }, [propFilteredKeys]);
+  // ====================== Open Keys ======================
+  const [openKeys, setOpenKeys] = React.useState([]);
+  const onOpenChange = keys => {
+    setOpenKeys(keys);
+  };
+  // search in tree mode column filter
+  const [searchValue, setSearchValue] = React.useState('');
+  const onSearch = e => {
+    const {
+      value
+    } = e.target;
+    setSearchValue(value);
+  };
+  // clear search value after close filter dropdown
+  React.useEffect(() => {
+    if (!visible) {
+      setSearchValue('');
+    }
+  }, [visible]);
+  // ======================= Submit ========================
+  const internalTriggerFilter = keys => {
+    const mergedKeys = (keys === null || keys === void 0 ? 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,
+      key: columnKey,
+      filteredKeys: mergedKeys
+    });
+  };
+  const onConfirm = () => {
+    triggerVisible(false);
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  const onReset = ({
+    confirm,
+    closeDropdown
+  } = {
+    confirm: false,
+    closeDropdown: false
+  }) => {
+    if (confirm) {
+      internalTriggerFilter([]);
+    }
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    setSearchValue('');
+    if (filterResetToDefaultFilteredValue) {
+      setFilteredKeysSync((defaultFilteredValue || []).map(key => String(key)));
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  const doFilter = ({
+    closeDropdown
+  } = {
+    closeDropdown: true
+  }) => {
+    if (closeDropdown) {
+      triggerVisible(false);
+    }
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+  const onVisibleChange = (newVisible, info) => {
+    if (info.source === 'trigger') {
+      if (newVisible && propFilteredKeys !== undefined) {
+        // Sync filteredKeys on appear in controlled mode (propFilteredKeys !== undefined)
+        setFilteredKeysSync(wrapStringListType(propFilteredKeys));
+      }
+      triggerVisible(newVisible);
+      if (!newVisible && !column.filterDropdown && filterOnClose) {
+        onConfirm();
+      }
+    }
+  };
+  // ======================== Style ========================
+  const dropdownMenuClass = classNames({
+    [`${dropdownPrefixCls}-menu-without-submenu`]: !hasSubMenu(column.filters || [])
+  });
+  const onCheckAll = e => {
+    if (e.target.checked) {
+      const allFilterKeys = flattenKeys(column === null || column === void 0 ? void 0 : column.filters).map(key => String(key));
+      setFilteredKeysSync(allFilterKeys);
+    } else {
+      setFilteredKeysSync([]);
+    }
+  };
+  const getTreeData = ({
+    filters
+  }) => (filters || []).map((filter, index) => {
+    const key = String(filter.value);
+    const item = {
+      title: filter.text,
+      key: filter.value !== undefined ? key : String(index)
+    };
+    if (filter.children) {
+      item.children = getTreeData({
+        filters: filter.children
+      });
+    }
+    return item;
+  });
+  const getFilterData = node => {
+    var _a;
+    return Object.assign(Object.assign({}, node), {
+      text: node.title,
+      value: node.key,
+      children: ((_a = node.children) === null || _a === void 0 ? void 0 : _a.map(item => getFilterData(item))) || []
+    });
+  };
+  let dropdownContent;
+  const {
+    direction,
+    renderEmpty
+  } = React.useContext(ConfigContext);
+  if (typeof column.filterDropdown === 'function') {
+    dropdownContent = column.filterDropdown({
+      prefixCls: `${dropdownPrefixCls}-custom`,
+      setSelectedKeys: selectedKeys => onSelectKeys({
+        selectedKeys: selectedKeys
+      }),
+      selectedKeys: getFilteredKeysSync(),
+      confirm: doFilter,
+      clearFilters: onReset,
+      filters: column.filters,
+      visible: mergedVisible,
+      close: () => {
+        triggerVisible(false);
+      }
+    });
+  } else if (column.filterDropdown) {
+    dropdownContent = column.filterDropdown;
+  } else {
+    const selectedKeys = getFilteredKeysSync() || [];
+    const getFilterComponent = () => {
+      var _a, _b;
+      const empty = (_a = renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Table.filter')) !== null && _a !== void 0 ? _a : (/*#__PURE__*/React.createElement(Empty, {
+        image: Empty.PRESENTED_IMAGE_SIMPLE,
+        description: locale.filterEmptyText,
+        styles: {
+          image: {
+            height: 24
+          }
+        },
+        style: {
+          margin: 0,
+          padding: '16px 0'
+        }
+      }));
+      if ((column.filters || []).length === 0) {
+        return empty;
+      }
+      if (filterMode === 'tree') {
+        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: `${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: `${tablePrefixCls}-filter-dropdown-checkall`,
+          onChange: onCheckAll
+        }, (_b = locale === null || locale === void 0 ? void 0 : locale.filterCheckall) !== null && _b !== void 0 ? _b : 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: `${dropdownPrefixCls}-menu`,
+          onCheck: onCheck,
+          checkedKeys: selectedKeys,
+          selectedKeys: selectedKeys,
+          showIcon: false,
+          treeData: getTreeData({
+            filters: column.filters
+          }),
+          autoExpandParent: true,
+          defaultExpandAll: true,
+          filterTreeNode: searchValue.trim() ? node => {
+            if (typeof filterSearch === 'function') {
+              return filterSearch(searchValue, getFilterData(node));
+            }
+            return searchValueMatched(searchValue, node.title);
+          } : undefined
+        })));
+      }
+      const items = renderFilterItems({
+        filters: column.filters || [],
+        filterSearch,
+        prefixCls,
+        filteredKeys: getFilteredKeysSync(),
+        filterMultiple,
+        searchValue
+      });
+      const isEmpty = items.every(item => 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: `${dropdownPrefixCls}-menu`,
+        className: dropdownMenuClass,
+        onSelect: onSelectKeys,
+        onDeselect: onSelectKeys,
+        selectedKeys: selectedKeys,
+        getPopupContainer: getPopupContainer,
+        openKeys: openKeys,
+        onOpenChange: onOpenChange,
+        items: items
+      })));
+    };
+    const getResetDisabled = () => {
+      if (filterResetToDefaultFilteredValue) {
+        return isEqual((defaultFilteredValue || []).map(key => String(key)), selectedKeys, true);
+      }
+      return selectedKeys.length === 0;
+    };
+    dropdownContent = /*#__PURE__*/React.createElement(React.Fragment, null, getFilterComponent(), /*#__PURE__*/React.createElement("div", {
+      className: `${prefixCls}-dropdown-btns`
+    }, /*#__PURE__*/React.createElement(Button, {
+      type: "link",
+      size: "small",
+      disabled: getResetDisabled(),
+      onClick: () => onReset()
+    }, locale.filterReset), /*#__PURE__*/React.createElement(Button, {
+      type: "primary",
+      size: "small",
+      onClick: onConfirm
+    }, locale.filterConfirm)));
+  }
+  // We should not block customize Menu with additional props
+  if (column.filterDropdown) {
+    dropdownContent = /*#__PURE__*/React.createElement(OverrideProvider, {
+      selectable: undefined
+    }, dropdownContent);
+  }
+  dropdownContent = /*#__PURE__*/React.createElement(FilterDropdownMenuWrapper, {
+    className: `${prefixCls}-dropdown`
+  }, dropdownContent);
+  const getDropdownTrigger = () => {
+    let filterIcon;
+    if (typeof column.filterIcon === 'function') {
+      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: classNames(`${prefixCls}-trigger`, {
+        active: filtered
+      }),
+      onClick: e => {
+        e.stopPropagation();
+      }
+    }, filterIcon);
+  };
+  const mergedDropdownProps = extendsObject({
+    trigger: ['click'],
+    placement: direction === 'rtl' ? 'bottomLeft' : 'bottomRight',
+    children: getDropdownTrigger(),
+    getPopupContainer
+  }, Object.assign(Object.assign({}, filterDropdownProps), {
+    rootClassName: classNames(rootClassName, filterDropdownProps.rootClassName),
+    open: mergedVisible,
+    onOpenChange: onVisibleChange,
+    popupRender: () => {
+      if (typeof (filterDropdownProps === null || filterDropdownProps === void 0 ? void 0 : filterDropdownProps.dropdownRender) === 'function') {
+        return filterDropdownProps.dropdownRender(dropdownContent);
+      }
+      return dropdownContent;
+    }
+  }));
+  return /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-column`
+  }, /*#__PURE__*/React.createElement("span", {
+    className: `${tablePrefixCls}-column-title`
+  }, children), /*#__PURE__*/React.createElement(Dropdown, Object.assign({}, mergedDropdownProps)));
+};
+export default FilterDropdown;

node_modules/antd/es/table/hooks/useFilter/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;

node_modules/antd/es/table/hooks/useFilter/FilterSearch.js

@@ -0,0 +1,29 @@
+"use client";
+
+import * as React from 'react';
+import SearchOutlined from "@ant-design/icons/es/icons/SearchOutlined";
+import Input from '../../../input/Input';
+const FilterSearch = props => {
+  const {
+    value,
+    filterSearch,
+    tablePrefixCls,
+    locale,
+    onChange
+  } = props;
+  if (!filterSearch) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: `${tablePrefixCls}-filter-dropdown-search`
+  }, /*#__PURE__*/React.createElement(Input, {
+    prefix: /*#__PURE__*/React.createElement(SearchOutlined, null),
+    placeholder: locale.filterSearchPlaceholder,
+    onChange: onChange,
+    value: value,
+    // for skip min-width of input
+    htmlSize: 1,
+    className: `${tablePrefixCls}-filter-dropdown-search-input`
+  }));
+};
+export default FilterSearch;

node_modules/antd/es/table/hooks/useFilter/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;

node_modules/antd/es/table/hooks/useFilter/FilterWrapper.js

@@ -0,0 +1,22 @@
+"use client";
+
+import * as React from 'react';
+import KeyCode from "rc-util/es/KeyCode";
+const onKeyDown = event => {
+  const {
+    keyCode
+  } = event;
+  if (keyCode === KeyCode.ENTER) {
+    event.stopPropagation();
+  }
+};
+const FilterDropdownMenuWrapper = /*#__PURE__*/React.forwardRef((props, ref) => (/*#__PURE__*/React.createElement("div", {
+  className: props.className,
+  onClick: e => e.stopPropagation(),
+  onKeyDown: onKeyDown,
+  ref: ref
+}, props.children)));
+if (process.env.NODE_ENV !== 'production') {
+  FilterDropdownMenuWrapper.displayName = 'FilterDropdownMenuWrapper';
+}
+export default FilterDropdownMenuWrapper;

node_modules/antd/es/table/hooks/useFilter/index.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;

node_modules/antd/es/table/hooks/useFilter/index.js

@@ -0,0 +1,200 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { devUseWarning } from '../../../_util/warning';
+import { getColumnKey, getColumnPos, renderColumnTitle } from '../../util';
+import FilterDropdown, { flattenKeys } from './FilterDropdown';
+const collectFilterStates = (columns, init, pos) => {
+  let filterStates = [];
+  (columns || []).forEach((column, index) => {
+    var _a;
+    const columnPos = getColumnPos(index, pos);
+    const filterDropdownIsDefined = column.filterDropdown !== undefined;
+    if (column.filters || filterDropdownIsDefined || 'onFilter' in column) {
+      if ('filteredValue' in column) {
+        // Controlled
+        let filteredValues = column.filteredValue;
+        if (!filterDropdownIsDefined) {
+          filteredValues = (_a = filteredValues === null || filteredValues === void 0 ? void 0 : filteredValues.map(String)) !== null && _a !== void 0 ? _a : filteredValues;
+        }
+        filterStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: filteredValues,
+          forceFiltered: column.filtered
+        });
+      } else {
+        // Uncontrolled
+        filterStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: init && column.defaultFilteredValue ? column.defaultFilteredValue : undefined,
+          forceFiltered: column.filtered
+        });
+      }
+    }
+    if ('children' in column) {
+      filterStates = [].concat(_toConsumableArray(filterStates), _toConsumableArray(collectFilterStates(column.children, init, columnPos)));
+    }
+  });
+  return filterStates;
+};
+function injectFilter(prefixCls, dropdownPrefixCls, columns, filterStates, locale, triggerFilter, getPopupContainer, pos, rootClassName) {
+  return columns.map((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    const {
+      filterOnClose = true,
+      filterMultiple = true,
+      filterMode,
+      filterSearch
+    } = column;
+    let newColumn = column;
+    if (newColumn.filters || newColumn.filterDropdown) {
+      const columnKey = getColumnKey(newColumn, columnPos);
+      const filterState = filterStates.find(({
+        key
+      }) => columnKey === key);
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        title: renderProps => (/*#__PURE__*/React.createElement(FilterDropdown, {
+          tablePrefixCls: prefixCls,
+          prefixCls: `${prefixCls}-filter`,
+          dropdownPrefixCls: dropdownPrefixCls,
+          column: newColumn,
+          columnKey: columnKey,
+          filterState: filterState,
+          filterOnClose: filterOnClose,
+          filterMultiple: filterMultiple,
+          filterMode: filterMode,
+          filterSearch: filterSearch,
+          triggerFilter: triggerFilter,
+          locale: locale,
+          getPopupContainer: getPopupContainer,
+          rootClassName: rootClassName
+        }, renderColumnTitle(column.title, renderProps)))
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        children: injectFilter(prefixCls, dropdownPrefixCls, newColumn.children, filterStates, locale, triggerFilter, getPopupContainer, columnPos, rootClassName)
+      });
+    }
+    return newColumn;
+  });
+}
+const generateFilterInfo = filterStates => {
+  const currentFilters = {};
+  filterStates.forEach(({
+    key,
+    filteredKeys,
+    column
+  }) => {
+    const keyAsString = key;
+    const {
+      filters,
+      filterDropdown
+    } = column;
+    if (filterDropdown) {
+      currentFilters[keyAsString] = filteredKeys || null;
+    } else if (Array.isArray(filteredKeys)) {
+      const keys = flattenKeys(filters);
+      currentFilters[keyAsString] = keys.filter(originKey => filteredKeys.includes(String(originKey)));
+    } else {
+      currentFilters[keyAsString] = null;
+    }
+  });
+  return currentFilters;
+};
+export const getFilterData = (data, filterStates, childrenColumnName) => {
+  const filterDatas = filterStates.reduce((currentData, filterState) => {
+    const {
+      column: {
+        onFilter,
+        filters
+      },
+      filteredKeys
+    } = filterState;
+    if (onFilter && filteredKeys && filteredKeys.length) {
+      return currentData
+      // shallow copy
+      .map(record => Object.assign({}, record)).filter(record => filteredKeys.some(key => {
+        const keys = flattenKeys(filters);
+        const keyIndex = keys.findIndex(k => String(k) === String(key));
+        const realKey = keyIndex !== -1 ? keys[keyIndex] : key;
+        // filter children
+        if (record[childrenColumnName]) {
+          record[childrenColumnName] = getFilterData(record[childrenColumnName], filterStates, childrenColumnName);
+        }
+        return onFilter(realKey, record);
+      }));
+    }
+    return currentData;
+  }, data);
+  return filterDatas;
+};
+const getMergedColumns = rawMergedColumns => rawMergedColumns.flatMap(column => {
+  if ('children' in column) {
+    return [column].concat(_toConsumableArray(getMergedColumns(column.children || [])));
+  }
+  return [column];
+});
+const useFilter = props => {
+  const {
+    prefixCls,
+    dropdownPrefixCls,
+    mergedColumns: rawMergedColumns,
+    onFilterChange,
+    getPopupContainer,
+    locale: tableLocale,
+    rootClassName
+  } = props;
+  const warning = devUseWarning('Table');
+  const mergedColumns = React.useMemo(() => getMergedColumns(rawMergedColumns || []), [rawMergedColumns]);
+  const [filterStates, setFilterStates] = React.useState(() => collectFilterStates(mergedColumns, true));
+  const mergedFilterStates = React.useMemo(() => {
+    const collectedStates = collectFilterStates(mergedColumns, false);
+    if (collectedStates.length === 0) {
+      return collectedStates;
+    }
+    let filteredKeysIsAllNotControlled = true;
+    let filteredKeysIsAllControlled = true;
+    collectedStates.forEach(({
+      filteredKeys
+    }) => {
+      if (filteredKeys !== undefined) {
+        filteredKeysIsAllNotControlled = false;
+      } else {
+        filteredKeysIsAllControlled = false;
+      }
+    });
+    // Return if not controlled
+    if (filteredKeysIsAllNotControlled) {
+      // Filter column may have been removed
+      const keyList = (mergedColumns || []).map((column, index) => getColumnKey(column, getColumnPos(index)));
+      return filterStates.filter(({
+        key
+      }) => keyList.includes(key)).map(item => {
+        const col = mergedColumns[keyList.indexOf(item.key)];
+        return Object.assign(Object.assign({}, item), {
+          column: Object.assign(Object.assign({}, item.column), col),
+          forceFiltered: col.filtered
+        });
+      });
+    }
+    process.env.NODE_ENV !== "production" ? warning(filteredKeysIsAllControlled, 'usage', 'Columns should all contain `filteredValue` or not contain `filteredValue`.') : void 0;
+    return collectedStates;
+  }, [mergedColumns, filterStates]);
+  const filters = React.useMemo(() => generateFilterInfo(mergedFilterStates), [mergedFilterStates]);
+  const triggerFilter = filterState => {
+    const newFilterStates = mergedFilterStates.filter(({
+      key
+    }) => key !== filterState.key);
+    newFilterStates.push(filterState);
+    setFilterStates(newFilterStates);
+    onFilterChange(generateFilterInfo(newFilterStates), newFilterStates);
+  };
+  const transformColumns = innerColumns => injectFilter(prefixCls, dropdownPrefixCls, innerColumns, mergedFilterStates, tableLocale, triggerFilter, getPopupContainer, undefined, rootClassName);
+  return [transformColumns, mergedFilterStates, filters];
+};
+export { flattenKeys };
+export default useFilter;

node_modules/antd/es/table/hooks/useLazyKVMap.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from '../../_util/type';
+import type { GetRowKey, Key } from '../interface';
+declare const useLazyKVMap: <RecordType extends AnyObject = AnyObject>(data: readonly RecordType[], childrenColumnName: string, getRowKey: GetRowKey<RecordType>) => readonly [(key: Key) => RecordType];
+export default useLazyKVMap;

node_modules/antd/es/table/hooks/useLazyKVMap.js

@@ -0,0 +1,29 @@
+import * as React from 'react';
+const useLazyKVMap = (data, childrenColumnName, getRowKey) => {
+  const mapCacheRef = React.useRef({});
+  function getRecordByKey(key) {
+    var _a;
+    if (!mapCacheRef.current || mapCacheRef.current.data !== data || mapCacheRef.current.childrenColumnName !== childrenColumnName || mapCacheRef.current.getRowKey !== getRowKey) {
+      const kvMap = new Map();
+      function dig(records) {
+        records.forEach((record, index) => {
+          const rowKey = getRowKey(record, index);
+          kvMap.set(rowKey, record);
+          if (record && typeof record === 'object' && childrenColumnName in record) {
+            dig(record[childrenColumnName] || []);
+          }
+        });
+      }
+      dig(data);
+      mapCacheRef.current = {
+        data,
+        childrenColumnName,
+        kvMap,
+        getRowKey
+      };
+    }
+    return (_a = mapCacheRef.current.kvMap) === null || _a === void 0 ? void 0 : _a.get(key);
+  }
+  return [getRecordByKey];
+};
+export default useLazyKVMap;

node_modules/antd/es/table/hooks/usePagination.d.ts

@@ -0,0 +1,5 @@
+import type { TablePaginationConfig } from '../interface';
+export declare const DEFAULT_PAGE_SIZE = 10;
+export declare function getPaginationParam(mergedPagination: TablePaginationConfig, pagination?: TablePaginationConfig | boolean): any;
+declare function usePagination(total: number, onChange: (current: number, pageSize: number) => void, pagination?: TablePaginationConfig | false): readonly [TablePaginationConfig, (current?: number, pageSize?: number) => void];
+export default usePagination;

node_modules/antd/es/table/hooks/usePagination.js

@@ -0,0 +1,67 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { useState } from 'react';
+import extendsObject from '../../_util/extendsObject';
+export const DEFAULT_PAGE_SIZE = 10;
+export function getPaginationParam(mergedPagination, pagination) {
+  const param = {
+    current: mergedPagination.current,
+    pageSize: mergedPagination.pageSize
+  };
+  const paginationObj = pagination && typeof pagination === 'object' ? pagination : {};
+  Object.keys(paginationObj).forEach(pageProp => {
+    const value = mergedPagination[pageProp];
+    if (typeof value !== 'function') {
+      param[pageProp] = value;
+    }
+  });
+  return param;
+}
+function usePagination(total, onChange, pagination) {
+  const _a = pagination && typeof pagination === 'object' ? pagination : {},
+    {
+      total: paginationTotal = 0
+    } = _a,
+    paginationObj = __rest(_a, ["total"]);
+  const [innerPagination, setInnerPagination] = useState(() => ({
+    current: 'defaultCurrent' in paginationObj ? paginationObj.defaultCurrent : 1,
+    pageSize: 'defaultPageSize' in paginationObj ? paginationObj.defaultPageSize : DEFAULT_PAGE_SIZE
+  }));
+  // ============ Basic Pagination Config ============
+  const mergedPagination = extendsObject(innerPagination, paginationObj, {
+    total: paginationTotal > 0 ? paginationTotal : total
+  });
+  // Reset `current` if data length or pageSize changed
+  const maxPage = Math.ceil((paginationTotal || total) / mergedPagination.pageSize);
+  if (mergedPagination.current > maxPage) {
+    // Prevent a maximum page count of 0
+    mergedPagination.current = maxPage || 1;
+  }
+  const refreshPagination = (current, pageSize) => {
+    setInnerPagination({
+      current: current !== null && current !== void 0 ? current : 1,
+      pageSize: pageSize || mergedPagination.pageSize
+    });
+  };
+  const onInternalChange = (current, pageSize) => {
+    var _a;
+    if (pagination) {
+      (_a = pagination.onChange) === null || _a === void 0 ? void 0 : _a.call(pagination, current, pageSize);
+    }
+    refreshPagination(current, pageSize);
+    onChange(current, pageSize || (mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.pageSize));
+  };
+  if (pagination === false) {
+    return [{}, () => {}];
+  }
+  return [Object.assign(Object.assign({}, mergedPagination), {
+    onChange: onInternalChange
+  }), refreshPagination];
+}
+export default usePagination;

node_modules/antd/es/table/hooks/useSelection.d.ts

@@ -0,0 +1,20 @@
+import type { AnyObject } from '../../_util/type';
+import type { ExpandType, GetPopupContainer, GetRowKey, Key, SelectionItem, TableLocale, TableRowSelection, TransformColumns } from '../interface';
+export declare const SELECTION_COLUMN: {};
+export declare const SELECTION_ALL: "SELECT_ALL";
+export declare const SELECTION_INVERT: "SELECT_INVERT";
+export declare const SELECTION_NONE: "SELECT_NONE";
+interface UseSelectionConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    pageData: RecordType[];
+    data: RecordType[];
+    getRowKey: GetRowKey<RecordType>;
+    getRecordByKey: (key: Key) => RecordType;
+    expandType: ExpandType;
+    childrenColumnName: string;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+}
+export type INTERNAL_SELECTION_ITEM = SelectionItem | typeof SELECTION_ALL | typeof SELECTION_INVERT | typeof SELECTION_NONE;
+declare const useSelection: <RecordType extends AnyObject = AnyObject>(config: UseSelectionConfig<RecordType>, rowSelection?: TableRowSelection<RecordType>) => readonly [TransformColumns<RecordType>, Set<Key>];
+export default useSelection;

node_modules/antd/es/table/hooks/useSelection.js

@@ -0,0 +1,536 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { useCallback, useMemo } from 'react';
+import DownOutlined from "@ant-design/icons/es/icons/DownOutlined";
+import classNames from 'classnames';
+import { INTERNAL_COL_DEFINE } from 'rc-table';
+import { arrAdd, arrDel } from "rc-tree/es/util";
+import { conductCheck } from "rc-tree/es/utils/conductUtil";
+import { convertDataToEntities } from "rc-tree/es/utils/treeUtil";
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import { useMultipleSelect } from '../../_util/hooks';
+import { devUseWarning } from '../../_util/warning';
+import Checkbox from '../../checkbox';
+import Dropdown from '../../dropdown';
+import Radio from '../../radio';
+// TODO: warning if use ajax!!!
+export const SELECTION_COLUMN = {};
+export const SELECTION_ALL = 'SELECT_ALL';
+export const SELECTION_INVERT = 'SELECT_INVERT';
+export const SELECTION_NONE = 'SELECT_NONE';
+const EMPTY_LIST = [];
+const flattenData = (childrenColumnName, data, list = []) => {
+  (data || []).forEach(record => {
+    list.push(record);
+    if (record && typeof record === 'object' && childrenColumnName in record) {
+      flattenData(childrenColumnName, record[childrenColumnName], list);
+    }
+  });
+  return list;
+};
+const useSelection = (config, rowSelection) => {
+  const {
+    preserveSelectedRowKeys,
+    selectedRowKeys,
+    defaultSelectedRowKeys,
+    getCheckboxProps,
+    getTitleCheckboxProps,
+    onChange: onSelectionChange,
+    onSelect,
+    onSelectAll,
+    onSelectInvert,
+    onSelectNone,
+    onSelectMultiple,
+    columnWidth: selectionColWidth,
+    type: selectionType,
+    selections,
+    fixed,
+    renderCell: customizeRenderCell,
+    hideSelectAll,
+    checkStrictly = true
+  } = rowSelection || {};
+  const {
+    prefixCls,
+    data,
+    pageData,
+    getRecordByKey,
+    getRowKey,
+    expandType,
+    childrenColumnName,
+    locale: tableLocale,
+    getPopupContainer
+  } = config;
+  const warning = devUseWarning('Table');
+  // ========================= MultipleSelect =========================
+  const [multipleSelect, updatePrevSelectedIndex] = useMultipleSelect(item => item);
+  // ========================= Keys =========================
+  const [mergedSelectedKeys, setMergedSelectedKeys] = useMergedState(selectedRowKeys || defaultSelectedRowKeys || EMPTY_LIST, {
+    value: selectedRowKeys
+  });
+  // ======================== Caches ========================
+  const preserveRecordsRef = React.useRef(new Map());
+  const updatePreserveRecordsCache = useCallback(keys => {
+    if (preserveSelectedRowKeys) {
+      const newCache = new Map();
+      // Keep key if mark as preserveSelectedRowKeys
+      keys.forEach(key => {
+        let record = getRecordByKey(key);
+        if (!record && preserveRecordsRef.current.has(key)) {
+          record = preserveRecordsRef.current.get(key);
+        }
+        newCache.set(key, record);
+      });
+      // Refresh to new cache
+      preserveRecordsRef.current = newCache;
+    }
+  }, [getRecordByKey, preserveSelectedRowKeys]);
+  // Update cache with selectedKeys
+  React.useEffect(() => {
+    updatePreserveRecordsCache(mergedSelectedKeys);
+  }, [mergedSelectedKeys]);
+  // Get flatten data
+  const flattedData = useMemo(() => flattenData(childrenColumnName, pageData), [childrenColumnName, pageData]);
+  const {
+    keyEntities
+  } = useMemo(() => {
+    if (checkStrictly) {
+      return {
+        keyEntities: null
+      };
+    }
+    let convertData = data;
+    if (preserveSelectedRowKeys) {
+      // use flattedData keys
+      const keysSet = new Set(flattedData.map((record, index) => getRowKey(record, index)));
+      // remove preserveRecords that duplicate data
+      const preserveRecords = Array.from(preserveRecordsRef.current).reduce((total, [key, value]) => keysSet.has(key) ? total : total.concat(value), []);
+      convertData = [].concat(_toConsumableArray(convertData), _toConsumableArray(preserveRecords));
+    }
+    return convertDataToEntities(convertData, {
+      externalGetKey: getRowKey,
+      childrenPropName: childrenColumnName
+    });
+  }, [data, getRowKey, checkStrictly, childrenColumnName, preserveSelectedRowKeys, flattedData]);
+  // Get all checkbox props
+  const checkboxPropsMap = useMemo(() => {
+    const map = new Map();
+    flattedData.forEach((record, index) => {
+      const key = getRowKey(record, index);
+      const checkboxProps = (getCheckboxProps ? getCheckboxProps(record) : null) || {};
+      map.set(key, checkboxProps);
+      process.env.NODE_ENV !== "production" ? warning(!('checked' in checkboxProps || 'defaultChecked' in checkboxProps), 'usage', 'Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.') : void 0;
+    });
+    return map;
+  }, [flattedData, getRowKey, getCheckboxProps]);
+  const isCheckboxDisabled = useCallback(r => {
+    const rowKey = getRowKey(r);
+    let checkboxProps;
+    if (checkboxPropsMap.has(rowKey)) {
+      checkboxProps = checkboxPropsMap.get(getRowKey(r));
+    } else {
+      checkboxProps = getCheckboxProps ? getCheckboxProps(r) : undefined;
+    }
+    return !!(checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.disabled);
+  }, [checkboxPropsMap, getRowKey]);
+  const [derivedSelectedKeys, derivedHalfSelectedKeys] = useMemo(() => {
+    if (checkStrictly) {
+      return [mergedSelectedKeys || [], []];
+    }
+    const {
+      checkedKeys,
+      halfCheckedKeys
+    } = conductCheck(mergedSelectedKeys, true, keyEntities, isCheckboxDisabled);
+    return [checkedKeys || [], halfCheckedKeys];
+  }, [mergedSelectedKeys, checkStrictly, keyEntities, isCheckboxDisabled]);
+  const derivedSelectedKeySet = useMemo(() => {
+    const keys = selectionType === 'radio' ? derivedSelectedKeys.slice(0, 1) : derivedSelectedKeys;
+    return new Set(keys);
+  }, [derivedSelectedKeys, selectionType]);
+  const derivedHalfSelectedKeySet = useMemo(() => selectionType === 'radio' ? new Set() : new Set(derivedHalfSelectedKeys), [derivedHalfSelectedKeys, selectionType]);
+  // Reset if rowSelection reset
+  React.useEffect(() => {
+    if (!rowSelection) {
+      setMergedSelectedKeys(EMPTY_LIST);
+    }
+  }, [!!rowSelection]);
+  const setSelectedKeys = useCallback((keys, method) => {
+    let availableKeys;
+    let records;
+    updatePreserveRecordsCache(keys);
+    if (preserveSelectedRowKeys) {
+      availableKeys = keys;
+      records = keys.map(key => preserveRecordsRef.current.get(key));
+    } else {
+      // Filter key which not exist in the `dataSource`
+      availableKeys = [];
+      records = [];
+      keys.forEach(key => {
+        const record = getRecordByKey(key);
+        if (record !== undefined) {
+          availableKeys.push(key);
+          records.push(record);
+        }
+      });
+    }
+    setMergedSelectedKeys(availableKeys);
+    onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(availableKeys, records, {
+      type: method
+    });
+  }, [setMergedSelectedKeys, getRecordByKey, onSelectionChange, preserveSelectedRowKeys]);
+  // ====================== Selections ======================
+  // Trigger single `onSelect` event
+  const triggerSingleSelection = useCallback((key, selected, keys, event) => {
+    if (onSelect) {
+      const rows = keys.map(k => getRecordByKey(k));
+      onSelect(getRecordByKey(key), selected, rows, event);
+    }
+    setSelectedKeys(keys, 'single');
+  }, [onSelect, getRecordByKey, setSelectedKeys]);
+  const mergedSelections = useMemo(() => {
+    if (!selections || hideSelectAll) {
+      return null;
+    }
+    const selectionList = selections === true ? [SELECTION_ALL, SELECTION_INVERT, SELECTION_NONE] : selections;
+    return selectionList.map(selection => {
+      if (selection === SELECTION_ALL) {
+        return {
+          key: 'all',
+          text: tableLocale.selectionAll,
+          onSelect() {
+            setSelectedKeys(data.map((record, index) => getRowKey(record, index)).filter(key => {
+              const checkProps = checkboxPropsMap.get(key);
+              return !(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled) || derivedSelectedKeySet.has(key);
+            }), 'all');
+          }
+        };
+      }
+      if (selection === SELECTION_INVERT) {
+        return {
+          key: 'invert',
+          text: tableLocale.selectInvert,
+          onSelect() {
+            const keySet = new Set(derivedSelectedKeySet);
+            pageData.forEach((record, index) => {
+              const key = getRowKey(record, index);
+              const checkProps = checkboxPropsMap.get(key);
+              if (!(checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled)) {
+                if (keySet.has(key)) {
+                  keySet.delete(key);
+                } else {
+                  keySet.add(key);
+                }
+              }
+            });
+            const keys = Array.from(keySet);
+            if (onSelectInvert) {
+              warning.deprecated(false, 'onSelectInvert', 'onChange');
+              onSelectInvert(keys);
+            }
+            setSelectedKeys(keys, 'invert');
+          }
+        };
+      }
+      if (selection === SELECTION_NONE) {
+        return {
+          key: 'none',
+          text: tableLocale.selectNone,
+          onSelect() {
+            onSelectNone === null || onSelectNone === void 0 ? void 0 : onSelectNone();
+            setSelectedKeys(Array.from(derivedSelectedKeySet).filter(key => {
+              const checkProps = checkboxPropsMap.get(key);
+              return checkProps === null || checkProps === void 0 ? void 0 : checkProps.disabled;
+            }), 'none');
+          }
+        };
+      }
+      return selection;
+    }).map(selection => Object.assign(Object.assign({}, selection), {
+      onSelect: (...rest) => {
+        var _a2;
+        var _a;
+        (_a = selection.onSelect) === null || _a === void 0 ? void 0 : (_a2 = _a).call.apply(_a2, [selection].concat(rest));
+        updatePrevSelectedIndex(null);
+      }
+    }));
+  }, [selections, derivedSelectedKeySet, pageData, getRowKey, onSelectInvert, setSelectedKeys]);
+  // ======================= Columns ========================
+  const transformColumns = useCallback(columns => {
+    var _a;
+    // >>>>>>>>>>> Skip if not exists `rowSelection`
+    if (!rowSelection) {
+      process.env.NODE_ENV !== "production" ? warning(!columns.includes(SELECTION_COLUMN), 'usage', '`rowSelection` is not config but `SELECTION_COLUMN` exists in the `columns`.') : void 0;
+      return columns.filter(col => col !== SELECTION_COLUMN);
+    }
+    // >>>>>>>>>>> Support selection
+    let cloneColumns = _toConsumableArray(columns);
+    const keySet = new Set(derivedSelectedKeySet);
+    // Record key only need check with enabled
+    const recordKeys = flattedData.map(getRowKey).filter(key => !checkboxPropsMap.get(key).disabled);
+    const checkedCurrentAll = recordKeys.every(key => keySet.has(key));
+    const checkedCurrentSome = recordKeys.some(key => keySet.has(key));
+    const onSelectAllChange = () => {
+      const changeKeys = [];
+      if (checkedCurrentAll) {
+        recordKeys.forEach(key => {
+          keySet.delete(key);
+          changeKeys.push(key);
+        });
+      } else {
+        recordKeys.forEach(key => {
+          if (!keySet.has(key)) {
+            keySet.add(key);
+            changeKeys.push(key);
+          }
+        });
+      }
+      const keys = Array.from(keySet);
+      onSelectAll === null || onSelectAll === void 0 ? void 0 : onSelectAll(!checkedCurrentAll, keys.map(k => getRecordByKey(k)), changeKeys.map(k => getRecordByKey(k)));
+      setSelectedKeys(keys, 'all');
+      updatePrevSelectedIndex(null);
+    };
+    // ===================== Render =====================
+    // Title Cell
+    let title;
+    let columnTitleCheckbox;
+    if (selectionType !== 'radio') {
+      let customizeSelections;
+      if (mergedSelections) {
+        const menu = {
+          getPopupContainer,
+          items: mergedSelections.map((selection, index) => {
+            const {
+              key,
+              text,
+              onSelect: onSelectionClick
+            } = selection;
+            return {
+              key: key !== null && key !== void 0 ? key : index,
+              onClick: () => {
+                onSelectionClick === null || onSelectionClick === void 0 ? void 0 : onSelectionClick(recordKeys);
+              },
+              label: text
+            };
+          })
+        };
+        customizeSelections = /*#__PURE__*/React.createElement("div", {
+          className: `${prefixCls}-selection-extra`
+        }, /*#__PURE__*/React.createElement(Dropdown, {
+          menu: menu,
+          getPopupContainer: getPopupContainer
+        }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(DownOutlined, null))));
+      }
+      const allDisabledData = flattedData.map((record, index) => {
+        const key = getRowKey(record, index);
+        const checkboxProps = checkboxPropsMap.get(key) || {};
+        return Object.assign({
+          checked: keySet.has(key)
+        }, checkboxProps);
+      }).filter(({
+        disabled
+      }) => disabled);
+      const allDisabled = !!allDisabledData.length && allDisabledData.length === flattedData.length;
+      const allDisabledAndChecked = allDisabled && allDisabledData.every(({
+        checked
+      }) => checked);
+      const allDisabledSomeChecked = allDisabled && allDisabledData.some(({
+        checked
+      }) => checked);
+      const customCheckboxProps = (getTitleCheckboxProps === null || getTitleCheckboxProps === void 0 ? void 0 : getTitleCheckboxProps()) || {};
+      const {
+        onChange,
+        disabled
+      } = customCheckboxProps;
+      columnTitleCheckbox = /*#__PURE__*/React.createElement(Checkbox, Object.assign({
+        "aria-label": customizeSelections ? 'Custom selection' : 'Select all'
+      }, customCheckboxProps, {
+        checked: !allDisabled ? !!flattedData.length && checkedCurrentAll : allDisabledAndChecked,
+        indeterminate: !allDisabled ? !checkedCurrentAll && checkedCurrentSome : !allDisabledAndChecked && allDisabledSomeChecked,
+        onChange: e => {
+          onSelectAllChange();
+          onChange === null || onChange === void 0 ? void 0 : onChange(e);
+        },
+        disabled: disabled !== null && disabled !== void 0 ? disabled : flattedData.length === 0 || allDisabled,
+        skipGroup: true
+      }));
+      title = !hideSelectAll && (/*#__PURE__*/React.createElement("div", {
+        className: `${prefixCls}-selection`
+      }, columnTitleCheckbox, customizeSelections));
+    }
+    // Body Cell
+    let renderCell;
+    if (selectionType === 'radio') {
+      renderCell = (_, record, index) => {
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        return {
+          node: (/*#__PURE__*/React.createElement(Radio, Object.assign({}, checkboxProps, {
+            checked: checked,
+            onClick: e => {
+              var _a;
+              e.stopPropagation();
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, e);
+            },
+            onChange: event => {
+              var _a;
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, event);
+            }
+          }))),
+          checked
+        };
+      };
+    } else {
+      renderCell = (_, record, index) => {
+        var _a;
+        const key = getRowKey(record, index);
+        const checked = keySet.has(key);
+        const indeterminate = derivedHalfSelectedKeySet.has(key);
+        const checkboxProps = checkboxPropsMap.get(key);
+        let mergedIndeterminate;
+        if (expandType === 'nest') {
+          mergedIndeterminate = indeterminate;
+          process.env.NODE_ENV !== "production" ? warning(typeof (checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== 'boolean', 'usage', 'set `indeterminate` using `rowSelection.getCheckboxProps` is not allowed with tree structured dataSource.') : void 0;
+        } else {
+          mergedIndeterminate = (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.indeterminate) !== null && _a !== void 0 ? _a : indeterminate;
+        }
+        // Record checked
+        return {
+          node: (/*#__PURE__*/React.createElement(Checkbox, Object.assign({}, checkboxProps, {
+            indeterminate: mergedIndeterminate,
+            checked: checked,
+            skipGroup: true,
+            onClick: e => {
+              var _a;
+              e.stopPropagation();
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onClick) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, e);
+            },
+            onChange: event => {
+              var _a;
+              const {
+                nativeEvent
+              } = event;
+              const {
+                shiftKey
+              } = nativeEvent;
+              const currentSelectedIndex = recordKeys.indexOf(key);
+              const isMultiple = derivedSelectedKeys.some(item => recordKeys.includes(item));
+              if (shiftKey && checkStrictly && isMultiple) {
+                const changedKeys = multipleSelect(currentSelectedIndex, recordKeys, keySet);
+                const keys = Array.from(keySet);
+                onSelectMultiple === null || onSelectMultiple === void 0 ? void 0 : onSelectMultiple(!checked, keys.map(recordKey => getRecordByKey(recordKey)), changedKeys.map(recordKey => getRecordByKey(recordKey)));
+                setSelectedKeys(keys, 'multiple');
+              } else {
+                // Single record selected
+                const originCheckedKeys = derivedSelectedKeys;
+                if (checkStrictly) {
+                  const checkedKeys = checked ? arrDel(originCheckedKeys, key) : arrAdd(originCheckedKeys, key);
+                  triggerSingleSelection(key, !checked, checkedKeys, nativeEvent);
+                } else {
+                  // Always fill first
+                  const result = conductCheck([].concat(_toConsumableArray(originCheckedKeys), [key]), true, keyEntities, isCheckboxDisabled);
+                  const {
+                    checkedKeys,
+                    halfCheckedKeys
+                  } = result;
+                  let nextCheckedKeys = checkedKeys;
+                  // If remove, we do it again to correction
+                  if (checked) {
+                    const tempKeySet = new Set(checkedKeys);
+                    tempKeySet.delete(key);
+                    nextCheckedKeys = conductCheck(Array.from(tempKeySet), {
+                      checked: false,
+                      halfCheckedKeys
+                    }, keyEntities, isCheckboxDisabled).checkedKeys;
+                  }
+                  triggerSingleSelection(key, !checked, nextCheckedKeys, nativeEvent);
+                }
+              }
+              if (checked) {
+                updatePrevSelectedIndex(null);
+              } else {
+                updatePrevSelectedIndex(currentSelectedIndex);
+              }
+              (_a = checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.onChange) === null || _a === void 0 ? void 0 : _a.call(checkboxProps, event);
+            }
+          }))),
+          checked
+        };
+      };
+    }
+    const renderSelectionCell = (_, record, index) => {
+      const {
+        node,
+        checked
+      } = renderCell(_, record, index);
+      if (customizeRenderCell) {
+        return customizeRenderCell(checked, record, index, node);
+      }
+      return node;
+    };
+    // Insert selection column if not exist
+    if (!cloneColumns.includes(SELECTION_COLUMN)) {
+      // Always after expand icon
+      if (cloneColumns.findIndex(col => {
+        var _a;
+        return ((_a = col[INTERNAL_COL_DEFINE]) === null || _a === void 0 ? void 0 : _a.columnType) === 'EXPAND_COLUMN';
+      }) === 0) {
+        const [expandColumn, ...restColumns] = cloneColumns;
+        cloneColumns = [expandColumn, SELECTION_COLUMN].concat(_toConsumableArray(restColumns));
+      } else {
+        // Normal insert at first column
+        cloneColumns = [SELECTION_COLUMN].concat(_toConsumableArray(cloneColumns));
+      }
+    }
+    // Deduplicate selection column
+    const selectionColumnIndex = cloneColumns.indexOf(SELECTION_COLUMN);
+    process.env.NODE_ENV !== "production" ? warning(cloneColumns.filter(col => col === SELECTION_COLUMN).length <= 1, 'usage', 'Multiple `SELECTION_COLUMN` exist in `columns`.') : void 0;
+    cloneColumns = cloneColumns.filter((column, index) => column !== SELECTION_COLUMN || index === selectionColumnIndex);
+    // Fixed column logic
+    const prevCol = cloneColumns[selectionColumnIndex - 1];
+    const nextCol = cloneColumns[selectionColumnIndex + 1];
+    let mergedFixed = fixed;
+    if (mergedFixed === undefined) {
+      if ((nextCol === null || nextCol === void 0 ? void 0 : nextCol.fixed) !== undefined) {
+        mergedFixed = nextCol.fixed;
+      } else if ((prevCol === null || prevCol === void 0 ? void 0 : prevCol.fixed) !== undefined) {
+        mergedFixed = prevCol.fixed;
+      }
+    }
+    if (mergedFixed && prevCol && ((_a = prevCol[INTERNAL_COL_DEFINE]) === null || _a === void 0 ? void 0 : _a.columnType) === 'EXPAND_COLUMN' && prevCol.fixed === undefined) {
+      prevCol.fixed = mergedFixed;
+    }
+    const columnCls = classNames(`${prefixCls}-selection-col`, {
+      [`${prefixCls}-selection-col-with-dropdown`]: selections && selectionType === 'checkbox'
+    });
+    const renderColumnTitle = () => {
+      if (!(rowSelection === null || rowSelection === void 0 ? void 0 : rowSelection.columnTitle)) {
+        return title;
+      }
+      if (typeof rowSelection.columnTitle === 'function') {
+        return rowSelection.columnTitle(columnTitleCheckbox);
+      }
+      return rowSelection.columnTitle;
+    };
+    // Replace with real selection column
+    const selectionColumn = {
+      fixed: mergedFixed,
+      width: selectionColWidth,
+      className: `${prefixCls}-selection-column`,
+      title: renderColumnTitle(),
+      render: renderSelectionCell,
+      onCell: rowSelection.onCell,
+      align: rowSelection.align,
+      [INTERNAL_COL_DEFINE]: {
+        className: columnCls
+      }
+    };
+    return cloneColumns.map(col => col === SELECTION_COLUMN ? selectionColumn : col);
+  }, [getRowKey, flattedData, rowSelection, derivedSelectedKeys, derivedSelectedKeySet, derivedHalfSelectedKeySet, selectionColWidth, mergedSelections, expandType, checkboxPropsMap, onSelectMultiple, triggerSingleSelection, isCheckboxDisabled]);
+  return [transformColumns, derivedSelectedKeySet];
+};
+export default useSelection;

node_modules/antd/es/table/hooks/useSorter.d.ts

@@ -0,0 +1,19 @@
+import type { AnyObject } from '../../_util/type';
+import type { ColumnsType, ColumnTitleProps, ColumnType, Key, SorterResult, SorterTooltipProps, SortOrder, TableLocale, TransformColumns } from '../interface';
+export interface SortState<RecordType = AnyObject> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    sortOrder: SortOrder | null;
+    multiplePriority: number | false;
+}
+export declare const getSortData: <RecordType extends AnyObject = AnyObject>(data: readonly RecordType[], sortStates: SortState<RecordType>[], childrenColumnName: string) => RecordType[];
+interface SorterConfig<RecordType = AnyObject> {
+    prefixCls: string;
+    mergedColumns: ColumnsType<RecordType>;
+    onSorterChange: (sorterResult: SorterResult<RecordType> | SorterResult<RecordType>[], sortStates: SortState<RecordType>[]) => void;
+    sortDirections: SortOrder[];
+    tableLocale?: TableLocale;
+    showSorterTooltip?: boolean | SorterTooltipProps;
+}
+declare const useFilterSorter: <RecordType extends AnyObject = AnyObject>(props: SorterConfig<RecordType>) => [TransformColumns<RecordType>, SortState<RecordType>[], ColumnTitleProps<RecordType>, () => SorterResult<RecordType> | SorterResult<RecordType>[]];
+export default useFilterSorter;

node_modules/antd/es/table/hooks/useSorter.js

@@ -0,0 +1,363 @@
+"use client";
+
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import CaretDownOutlined from "@ant-design/icons/es/icons/CaretDownOutlined";
+import CaretUpOutlined from "@ant-design/icons/es/icons/CaretUpOutlined";
+import classNames from 'classnames';
+import KeyCode from "rc-util/es/KeyCode";
+import Tooltip from '../../tooltip';
+import { getColumnKey, getColumnPos, renderColumnTitle, safeColumnTitle } from '../util';
+const ASCEND = 'ascend';
+const DESCEND = 'descend';
+const getMultiplePriority = column => {
+  if (typeof column.sorter === 'object' && typeof column.sorter.multiple === 'number') {
+    return column.sorter.multiple;
+  }
+  return false;
+};
+const getSortFunction = sorter => {
+  if (typeof sorter === 'function') {
+    return sorter;
+  }
+  if (sorter && typeof sorter === 'object' && sorter.compare) {
+    return sorter.compare;
+  }
+  return false;
+};
+const nextSortDirection = (sortDirections, current) => {
+  if (!current) {
+    return sortDirections[0];
+  }
+  return sortDirections[sortDirections.indexOf(current) + 1];
+};
+const collectSortStates = (columns, init, pos) => {
+  let sortStates = [];
+  const pushState = (column, columnPos) => {
+    sortStates.push({
+      column,
+      key: getColumnKey(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  };
+  (columns || []).forEach((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    if (column.children) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      }
+      sortStates = [].concat(_toConsumableArray(sortStates), _toConsumableArray(collectSortStates(column.children, init, columnPos)));
+    } else if (column.sorter) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      } else if (init && column.defaultSortOrder) {
+        // Default sorter
+        sortStates.push({
+          column,
+          key: getColumnKey(column, columnPos),
+          multiplePriority: getMultiplePriority(column),
+          sortOrder: column.defaultSortOrder
+        });
+      }
+    }
+  });
+  return sortStates;
+};
+const injectSorter = (prefixCls, columns, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos) => {
+  const finalColumns = (columns || []).map((column, index) => {
+    const columnPos = getColumnPos(index, pos);
+    let newColumn = column;
+    if (newColumn.sorter) {
+      const sortDirections = newColumn.sortDirections || defaultSortDirections;
+      const showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      const columnKey = getColumnKey(newColumn, columnPos);
+      const sorterState = sorterStates.find(({
+        key
+      }) => key === columnKey);
+      const sortOrder = sorterState ? sorterState.sortOrder : null;
+      const nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+      let sorter;
+      if (column.sortIcon) {
+        sorter = column.sortIcon({
+          sortOrder
+        });
+      } else {
+        const upNode = sortDirections.includes(ASCEND) && (/*#__PURE__*/React.createElement(CaretUpOutlined, {
+          className: classNames(`${prefixCls}-column-sorter-up`, {
+            active: sortOrder === ASCEND
+          })
+        }));
+        const downNode = sortDirections.includes(DESCEND) && (/*#__PURE__*/React.createElement(CaretDownOutlined, {
+          className: classNames(`${prefixCls}-column-sorter-down`, {
+            active: sortOrder === DESCEND
+          })
+        }));
+        sorter = /*#__PURE__*/React.createElement("span", {
+          className: classNames(`${prefixCls}-column-sorter`, {
+            [`${prefixCls}-column-sorter-full`]: !!(upNode && downNode)
+          })
+        }, /*#__PURE__*/React.createElement("span", {
+          className: `${prefixCls}-column-sorter-inner`,
+          "aria-hidden": "true"
+        }, upNode, downNode));
+      }
+      const {
+        cancelSort,
+        triggerAsc,
+        triggerDesc
+      } = tableLocale || {};
+      let sortTip = cancelSort;
+      if (nextSortOrder === DESCEND) {
+        sortTip = triggerDesc;
+      } else if (nextSortOrder === ASCEND) {
+        sortTip = triggerAsc;
+      }
+      const tooltipProps = typeof showSorterTooltip === 'object' ? Object.assign({
+        title: sortTip
+      }, showSorterTooltip) : {
+        title: sortTip
+      };
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        className: classNames(newColumn.className, {
+          [`${prefixCls}-column-sort`]: sortOrder
+        }),
+        title: renderProps => {
+          const columnSortersClass = `${prefixCls}-column-sorters`;
+          const renderColumnTitleWrapper = /*#__PURE__*/React.createElement("span", {
+            className: `${prefixCls}-column-title`
+          }, renderColumnTitle(column.title, renderProps));
+          const renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: columnSortersClass
+          }, renderColumnTitleWrapper, sorter);
+          if (showSorterTooltip) {
+            if (typeof showSorterTooltip !== 'boolean' && (showSorterTooltip === null || showSorterTooltip === void 0 ? void 0 : showSorterTooltip.target) === 'sorter-icon') {
+              return /*#__PURE__*/React.createElement("div", {
+                className: classNames(columnSortersClass, `${columnSortersClass}-tooltip-target-sorter`)
+              }, renderColumnTitleWrapper, /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, tooltipProps), sorter));
+            }
+            return /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, tooltipProps), renderSortTitle);
+          }
+          return renderSortTitle;
+        },
+        onHeaderCell: col => {
+          var _a;
+          const cell = ((_a = column.onHeaderCell) === null || _a === void 0 ? void 0 : _a.call(column, col)) || {};
+          const originOnClick = cell.onClick;
+          const originOKeyDown = cell.onKeyDown;
+          cell.onClick = event => {
+            triggerSorter({
+              column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+            originOnClick === null || originOnClick === void 0 ? void 0 : originOnClick(event);
+          };
+          cell.onKeyDown = event => {
+            if (event.keyCode === KeyCode.ENTER) {
+              triggerSorter({
+                column,
+                key: columnKey,
+                sortOrder: nextSortOrder,
+                multiplePriority: getMultiplePriority(column)
+              });
+              originOKeyDown === null || originOKeyDown === void 0 ? void 0 : originOKeyDown(event);
+            }
+          };
+          const renderTitle = safeColumnTitle(column.title, {});
+          const displayTitle = renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle.toString();
+          // Inform the screen-reader so it can tell the visually impaired user which column is sorted
+          if (sortOrder) {
+            cell['aria-sort'] = sortOrder === 'ascend' ? 'ascending' : 'descending';
+          }
+          cell['aria-label'] = displayTitle || '';
+          cell.className = classNames(cell.className, `${prefixCls}-column-has-sorters`);
+          cell.tabIndex = 0;
+          if (column.ellipsis) {
+            cell.title = (renderTitle !== null && renderTitle !== void 0 ? renderTitle : '').toString();
+          }
+          return cell;
+        }
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        children: injectSorter(prefixCls, newColumn.children, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos)
+      });
+    }
+    return newColumn;
+  });
+  return finalColumns;
+};
+const stateToInfo = sorterState => {
+  const {
+    column,
+    sortOrder
+  } = sorterState;
+  return {
+    column,
+    order: sortOrder,
+    field: column.dataIndex,
+    columnKey: column.key
+  };
+};
+const generateSorterInfo = sorterStates => {
+  const activeSorters = sorterStates.filter(({
+    sortOrder
+  }) => sortOrder).map(stateToInfo);
+  // =========== Legacy compatible support ===========
+  // https://github.com/ant-design/ant-design/pull/19226
+  if (activeSorters.length === 0 && sorterStates.length) {
+    const lastIndex = sorterStates.length - 1;
+    return Object.assign(Object.assign({}, stateToInfo(sorterStates[lastIndex])), {
+      column: undefined,
+      order: undefined,
+      field: undefined,
+      columnKey: undefined
+    });
+  }
+  if (activeSorters.length <= 1) {
+    return activeSorters[0] || {};
+  }
+  return activeSorters;
+};
+export const getSortData = (data, sortStates, childrenColumnName) => {
+  const innerSorterStates = sortStates.slice().sort((a, b) => b.multiplePriority - a.multiplePriority);
+  const cloneData = data.slice();
+  const runningSorters = innerSorterStates.filter(({
+    column: {
+      sorter
+    },
+    sortOrder
+  }) => getSortFunction(sorter) && sortOrder);
+  // Skip if no sorter needed
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+  return cloneData.sort((record1, record2) => {
+    for (let i = 0; i < runningSorters.length; i += 1) {
+      const sorterState = runningSorters[i];
+      const {
+        column: {
+          sorter
+        },
+        sortOrder
+      } = sorterState;
+      const compareFn = getSortFunction(sorter);
+      if (compareFn && sortOrder) {
+        const compareResult = compareFn(record1, record2, sortOrder);
+        if (compareResult !== 0) {
+          return sortOrder === ASCEND ? compareResult : -compareResult;
+        }
+      }
+    }
+    return 0;
+  }).map(record => {
+    const subRecords = record[childrenColumnName];
+    if (subRecords) {
+      return Object.assign(Object.assign({}, record), {
+        [childrenColumnName]: getSortData(subRecords, sortStates, childrenColumnName)
+      });
+    }
+    return record;
+  });
+};
+const useFilterSorter = props => {
+  const {
+    prefixCls,
+    mergedColumns,
+    sortDirections,
+    tableLocale,
+    showSorterTooltip,
+    onSorterChange
+  } = props;
+  const [sortStates, setSortStates] = React.useState(() => collectSortStates(mergedColumns, true));
+  const getColumnKeys = (columns, pos) => {
+    const newKeys = [];
+    columns.forEach((item, index) => {
+      const columnPos = getColumnPos(index, pos);
+      newKeys.push(getColumnKey(item, columnPos));
+      if (Array.isArray(item.children)) {
+        const childKeys = getColumnKeys(item.children, columnPos);
+        newKeys.push.apply(newKeys, _toConsumableArray(childKeys));
+      }
+    });
+    return newKeys;
+  };
+  const mergedSorterStates = React.useMemo(() => {
+    let validate = true;
+    const collectedStates = collectSortStates(mergedColumns, false);
+    // Return if not controlled
+    if (!collectedStates.length) {
+      const mergedColumnsKeys = getColumnKeys(mergedColumns);
+      return sortStates.filter(({
+        key
+      }) => mergedColumnsKeys.includes(key));
+    }
+    const validateStates = [];
+    function patchStates(state) {
+      if (validate) {
+        validateStates.push(state);
+      } else {
+        validateStates.push(Object.assign(Object.assign({}, state), {
+          sortOrder: null
+        }));
+      }
+    }
+    let multipleMode = null;
+    collectedStates.forEach(state => {
+      if (multipleMode === null) {
+        patchStates(state);
+        if (state.sortOrder) {
+          if (state.multiplePriority === false) {
+            validate = false;
+          } else {
+            multipleMode = true;
+          }
+        }
+      } else if (multipleMode && state.multiplePriority !== false) {
+        patchStates(state);
+      } else {
+        validate = false;
+        patchStates(state);
+      }
+    });
+    return validateStates;
+  }, [mergedColumns, sortStates]);
+  // Get render columns title required props
+  const columnTitleSorterProps = React.useMemo(() => {
+    var _a, _b;
+    const sortColumns = mergedSorterStates.map(({
+      column,
+      sortOrder
+    }) => ({
+      column,
+      order: sortOrder
+    }));
+    return {
+      sortColumns,
+      // Legacy
+      sortColumn: (_a = sortColumns[0]) === null || _a === void 0 ? void 0 : _a.column,
+      sortOrder: (_b = sortColumns[0]) === null || _b === void 0 ? void 0 : _b.order
+    };
+  }, [mergedSorterStates]);
+  const triggerSorter = sortState => {
+    let newSorterStates;
+    if (sortState.multiplePriority === false || !mergedSorterStates.length || mergedSorterStates[0].multiplePriority === false) {
+      newSorterStates = [sortState];
+    } else {
+      newSorterStates = [].concat(_toConsumableArray(mergedSorterStates.filter(({
+        key
+      }) => key !== sortState.key)), [sortState]);
+    }
+    setSortStates(newSorterStates);
+    onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+  };
+  const transformColumns = innerColumns => injectSorter(prefixCls, innerColumns, mergedSorterStates, triggerSorter, sortDirections, tableLocale, showSorterTooltip);
+  const getSorters = () => generateSorterInfo(mergedSorterStates);
+  return [transformColumns, mergedSorterStates, columnTitleSorterProps, getSorters];
+};
+export default useFilterSorter;

node_modules/antd/es/table/hooks/useTitleColumns.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from 'antd/es/_util/type';
+import type { ColumnTitleProps, TransformColumns } from '../interface';
+declare const useTitleColumns: <RecordType extends AnyObject = AnyObject>(columnTitleProps: ColumnTitleProps<RecordType>) => readonly [TransformColumns<RecordType>];
+export default useTitleColumns;

node_modules/antd/es/table/hooks/useTitleColumns.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { renderColumnTitle } from '../util';
+const fillTitle = (columns, columnTitleProps) => {
+  const finalColumns = columns.map(column => {
+    const cloneColumn = Object.assign({}, column);
+    cloneColumn.title = renderColumnTitle(column.title, columnTitleProps);
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+    return cloneColumn;
+  });
+  return finalColumns;
+};
+const useTitleColumns = columnTitleProps => {
+  const filledColumns = React.useCallback(columns => fillTitle(columns, columnTitleProps), [columnTitleProps]);
+  return [filledColumns];
+};
+export default useTitleColumns;