Latest updates from IceHrmPro

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

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { ColumnType, Key, TableLocale, GetPopupContainer } from '../../interface';
+import { FilterState } from '.';
+export interface FilterDropdownProps<RecordType> {
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    column: ColumnType<RecordType>;
+    filterState?: FilterState<RecordType>;
+    filterMultiple: boolean;
+    columnKey: Key;
+    children: React.ReactNode;
+    triggerFilter: (filterState: FilterState<RecordType>) => void;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+}
+declare function FilterDropdown<RecordType>(props: FilterDropdownProps<RecordType>): JSX.Element;
+export default FilterDropdown;

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

@@ -0,0 +1,250 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import isEqual from 'lodash/isEqual';
+import FilterFilled from '@ant-design/icons/FilterFilled';
+import Button from '../../../button';
+import Menu from '../../../menu';
+import Checkbox from '../../../checkbox';
+import Radio from '../../../radio';
+import Dropdown from '../../../dropdown';
+import FilterDropdownMenuWrapper from './FilterWrapper';
+import useSyncState from '../useSyncState';
+var SubMenu = Menu.SubMenu,
+    MenuItem = Menu.Item;
+
+function hasSubMenu(filters) {
+  return filters.some(function (_ref) {
+    var children = _ref.children;
+    return children;
+  });
+}
+
+function renderFilterItems(filters, prefixCls, filteredKeys, multiple) {
+  return filters.map(function (filter, index) {
+    var key = String(filter.value);
+
+    if (filter.children) {
+      return /*#__PURE__*/React.createElement(SubMenu, {
+        key: key || index,
+        title: filter.text,
+        popupClassName: "".concat(prefixCls, "-dropdown-submenu")
+      }, renderFilterItems(filter.children, prefixCls, filteredKeys, multiple));
+    }
+
+    var Component = multiple ? Checkbox : Radio;
+    return /*#__PURE__*/React.createElement(MenuItem, {
+      key: filter.value !== undefined ? key : index
+    }, /*#__PURE__*/React.createElement(Component, {
+      checked: filteredKeys.includes(key)
+    }), /*#__PURE__*/React.createElement("span", null, filter.text));
+  });
+}
+
+function FilterDropdown(props) {
+  var prefixCls = props.prefixCls,
+      column = props.column,
+      dropdownPrefixCls = props.dropdownPrefixCls,
+      columnKey = props.columnKey,
+      filterMultiple = props.filterMultiple,
+      filterState = props.filterState,
+      triggerFilter = props.triggerFilter,
+      locale = props.locale,
+      children = props.children,
+      getPopupContainer = props.getPopupContainer;
+  var filterDropdownVisible = column.filterDropdownVisible,
+      onFilterDropdownVisibleChange = column.onFilterDropdownVisibleChange;
+
+  var _React$useState = React.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      visible = _React$useState2[0],
+      setVisible = _React$useState2[1];
+
+  var filtered = !!(filterState && (filterState.filteredKeys || filterState.forceFiltered));
+
+  var triggerVisible = function triggerVisible(newVisible) {
+    setVisible(newVisible);
+
+    if (onFilterDropdownVisibleChange) {
+      onFilterDropdownVisibleChange(newVisible);
+    }
+  };
+
+  var mergedVisible = typeof filterDropdownVisible === 'boolean' ? filterDropdownVisible : visible; // ===================== Select Keys =====================
+
+  var propFilteredKeys = filterState && filterState.filteredKeys;
+
+  var _useSyncState = useSyncState(propFilteredKeys || []),
+      _useSyncState2 = _slicedToArray(_useSyncState, 2),
+      getFilteredKeysSync = _useSyncState2[0],
+      setFilteredKeysSync = _useSyncState2[1];
+
+  var onSelectKeys = function onSelectKeys(_ref2) {
+    var selectedKeys = _ref2.selectedKeys;
+    setFilteredKeysSync(selectedKeys);
+  };
+
+  React.useEffect(function () {
+    onSelectKeys({
+      selectedKeys: propFilteredKeys || []
+    });
+  }, [propFilteredKeys]); // ====================== Open Keys ======================
+
+  var _React$useState3 = React.useState([]),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      openKeys = _React$useState4[0],
+      setOpenKeys = _React$useState4[1];
+
+  var openRef = React.useRef();
+
+  var onOpenChange = function onOpenChange(keys) {
+    openRef.current = window.setTimeout(function () {
+      setOpenKeys(keys);
+    });
+  };
+
+  var onMenuClick = function onMenuClick() {
+    window.clearTimeout(openRef.current);
+  };
+
+  React.useEffect(function () {
+    return function () {
+      window.clearTimeout(openRef.current);
+    };
+  }, []); // ======================= Submit ========================
+
+  var internalTriggerFilter = function internalTriggerFilter(keys) {
+    triggerVisible(false);
+    var mergedKeys = keys && keys.length ? keys : null;
+
+    if (mergedKeys === null && (!filterState || !filterState.filteredKeys)) {
+      return null;
+    }
+
+    if (isEqual(mergedKeys, filterState === null || filterState === void 0 ? void 0 : filterState.filteredKeys)) {
+      return null;
+    }
+
+    triggerFilter({
+      column: column,
+      key: columnKey,
+      filteredKeys: mergedKeys
+    });
+  };
+
+  var onConfirm = function onConfirm() {
+    internalTriggerFilter(getFilteredKeysSync());
+  };
+
+  var onReset = function onReset() {
+    setFilteredKeysSync([]);
+    internalTriggerFilter([]);
+  };
+
+  var onVisibleChange = function onVisibleChange(newVisible) {
+    triggerVisible(newVisible); // Default will filter when closed
+
+    if (!newVisible && !column.filterDropdown) {
+      onConfirm();
+    }
+  }; // ======================== Style ========================
+
+
+  var dropdownMenuClass = classNames(_defineProperty({}, "".concat(dropdownPrefixCls, "-menu-without-submenu"), !hasSubMenu(column.filters || [])));
+  var dropdownContent;
+
+  if (typeof column.filterDropdown === 'function') {
+    dropdownContent = column.filterDropdown({
+      prefixCls: "".concat(dropdownPrefixCls, "-custom"),
+      setSelectedKeys: function setSelectedKeys(selectedKeys) {
+        return onSelectKeys({
+          selectedKeys: selectedKeys
+        });
+      },
+      selectedKeys: getFilteredKeysSync(),
+      confirm: onConfirm,
+      clearFilters: onReset,
+      filters: column.filters,
+      visible: mergedVisible
+    });
+  } else if (column.filterDropdown) {
+    dropdownContent = column.filterDropdown;
+  } else {
+    var selectedKeys = getFilteredKeysSync() || [];
+    dropdownContent = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Menu, {
+      multiple: filterMultiple,
+      prefixCls: "".concat(dropdownPrefixCls, "-menu"),
+      className: dropdownMenuClass,
+      onClick: onMenuClick,
+      onSelect: onSelectKeys,
+      onDeselect: onSelectKeys,
+      selectedKeys: selectedKeys,
+      getPopupContainer: getPopupContainer,
+      openKeys: openKeys,
+      onOpenChange: onOpenChange
+    }, renderFilterItems(column.filters || [], prefixCls, getFilteredKeysSync(), filterMultiple)), /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-dropdown-btns")
+    }, /*#__PURE__*/React.createElement(Button, {
+      type: "link",
+      size: "small",
+      disabled: selectedKeys.length === 0,
+      onClick: onReset
+    }, locale.filterReset), /*#__PURE__*/React.createElement(Button, {
+      type: "primary",
+      size: "small",
+      onClick: onConfirm
+    }, locale.filterConfirm)));
+  }
+
+  var menu = /*#__PURE__*/React.createElement(FilterDropdownMenuWrapper, {
+    className: "".concat(prefixCls, "-dropdown")
+  }, dropdownContent);
+  var 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("div", {
+    className: classNames("".concat(prefixCls, "-column"))
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-column-title")
+  }, children), /*#__PURE__*/React.createElement("span", {
+    className: classNames("".concat(prefixCls, "-trigger-container"), _defineProperty({}, "".concat(prefixCls, "-trigger-container-open"), mergedVisible)),
+    onClick: function onClick(e) {
+      e.stopPropagation();
+    }
+  }, /*#__PURE__*/React.createElement(Dropdown, {
+    overlay: menu,
+    trigger: ['click'],
+    visible: mergedVisible,
+    onVisibleChange: onVisibleChange,
+    getPopupContainer: getPopupContainer,
+    placement: "bottomRight"
+  }, /*#__PURE__*/React.createElement("span", {
+    role: "button",
+    tabIndex: -1,
+    className: classNames("".concat(prefixCls, "-trigger"), {
+      active: filtered
+    })
+  }, filterIcon))));
+}
+
+export default FilterDropdown;

web/node_modules/antd/es/table/hooks/useFilter/FilterWrapper.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface FilterDropdownMenuWrapperProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+declare const FilterDropdownMenuWrapper: (props: FilterDropdownMenuWrapperProps) => JSX.Element;
+export default FilterDropdownMenuWrapper;

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

@@ -0,0 +1,12 @@
+import * as React from 'react';
+
+var FilterDropdownMenuWrapper = function FilterDropdownMenuWrapper(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    }
+  }, props.children);
+};
+
+export default FilterDropdownMenuWrapper;

web/node_modules/antd/es/table/hooks/useFilter/index.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { TransformColumns, ColumnsType, ColumnType, Key, TableLocale, GetPopupContainer } from '../../interface';
+export interface FilterState<RecordType> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    filteredKeys?: Key[] | null;
+    forceFiltered?: boolean;
+}
+export declare function getFilterData<RecordType>(data: RecordType[], filterStates: FilterState<RecordType>[]): RecordType[];
+interface FilterConfig<RecordType> {
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    locale: TableLocale;
+    onFilterChange: (filters: Record<string, Key[] | null>, filterStates: FilterState<RecordType>[]) => void;
+    getPopupContainer?: GetPopupContainer;
+}
+declare function useFilter<RecordType>({ prefixCls, dropdownPrefixCls, columns, children, onFilterChange, getPopupContainer, locale: tableLocale, }: FilterConfig<RecordType>): [TransformColumns<RecordType>, FilterState<RecordType>[], () => Record<string, Key[] | null>];
+export default useFilter;

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

@@ -0,0 +1,195 @@
+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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) 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 { convertChildrenToColumns } from "rc-table/es/hooks/useColumns";
+import { getColumnPos, renderColumnTitle, getColumnKey } from '../../util';
+import FilterDropdown from './FilterDropdown';
+
+function collectFilterStates(columns, init, pos) {
+  var filterStates = [];
+  (columns || []).forEach(function (column, index) {
+    var columnPos = getColumnPos(index, pos);
+
+    if ('children' in column) {
+      filterStates = [].concat(_toConsumableArray(filterStates), _toConsumableArray(collectFilterStates(column.children, init, columnPos)));
+    } else if (column.filters || 'filterDropdown' in column || 'onFilter' in column) {
+      if ('filteredValue' in column) {
+        // Controlled
+        filterStates.push({
+          column: column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: column.filteredValue,
+          forceFiltered: column.filtered
+        });
+      } else {
+        // Uncontrolled
+        filterStates.push({
+          column: column,
+          key: getColumnKey(column, columnPos),
+          filteredKeys: init && column.defaultFilteredValue ? column.defaultFilteredValue : undefined,
+          forceFiltered: column.filtered
+        });
+      }
+    }
+  });
+  return filterStates;
+}
+
+function injectFilter(prefixCls, dropdownPrefixCls, columns, filterStates, triggerFilter, getPopupContainer, locale, pos) {
+  return columns.map(function (column, index) {
+    var columnPos = getColumnPos(index, pos);
+    var _column$filterMultipl = column.filterMultiple,
+        filterMultiple = _column$filterMultipl === void 0 ? true : _column$filterMultipl;
+
+    if (column.filters || 'filterDropdown' in column) {
+      var columnKey = getColumnKey(column, columnPos);
+      var filterState = filterStates.find(function (_ref) {
+        var key = _ref.key;
+        return columnKey === key;
+      });
+      return _extends(_extends({}, column), {
+        title: function title(renderProps) {
+          return /*#__PURE__*/React.createElement(FilterDropdown, {
+            prefixCls: "".concat(prefixCls, "-filter"),
+            dropdownPrefixCls: dropdownPrefixCls,
+            column: column,
+            columnKey: columnKey,
+            filterState: filterState,
+            filterMultiple: filterMultiple,
+            triggerFilter: triggerFilter,
+            locale: locale,
+            getPopupContainer: getPopupContainer
+          }, renderColumnTitle(column.title, renderProps));
+        }
+      });
+    }
+
+    if ('children' in column) {
+      return _extends(_extends({}, column), {
+        children: injectFilter(prefixCls, dropdownPrefixCls, column.children, filterStates, triggerFilter, getPopupContainer, locale, columnPos)
+      });
+    }
+
+    return column;
+  });
+}
+
+function generateFilterInfo(filterStates) {
+  var currentFilters = {};
+  filterStates.forEach(function (_ref2) {
+    var key = _ref2.key,
+        filteredKeys = _ref2.filteredKeys;
+    currentFilters[key] = filteredKeys || null;
+  });
+  return currentFilters;
+}
+
+function flattenKeys(filters) {
+  var keys = [];
+  (filters || []).forEach(function (_ref3) {
+    var value = _ref3.value,
+        children = _ref3.children;
+    keys.push(value);
+
+    if (children) {
+      keys = [].concat(_toConsumableArray(keys), _toConsumableArray(flattenKeys(children)));
+    }
+  });
+  return keys;
+}
+
+export function getFilterData(data, filterStates) {
+  return filterStates.reduce(function (currentData, filterState) {
+    var _filterState$column = filterState.column,
+        onFilter = _filterState$column.onFilter,
+        filters = _filterState$column.filters,
+        filteredKeys = filterState.filteredKeys;
+
+    if (onFilter && filteredKeys && filteredKeys.length) {
+      return currentData.filter(function (record) {
+        return filteredKeys.some(function (key) {
+          var keys = flattenKeys(filters);
+          var keyIndex = keys.findIndex(function (k) {
+            return String(k) === String(key);
+          });
+          var realKey = keyIndex !== -1 ? keys[keyIndex] : key;
+          return onFilter(realKey, record);
+        });
+      });
+    }
+
+    return currentData;
+  }, data);
+}
+
+function useFilter(_ref4) {
+  var prefixCls = _ref4.prefixCls,
+      dropdownPrefixCls = _ref4.dropdownPrefixCls,
+      columns = _ref4.columns,
+      children = _ref4.children,
+      onFilterChange = _ref4.onFilterChange,
+      getPopupContainer = _ref4.getPopupContainer,
+      tableLocale = _ref4.locale;
+  var mergedColumns = React.useMemo(function () {
+    return columns || convertChildrenToColumns(children);
+  }, [children, columns]);
+
+  var _React$useState = React.useState(collectFilterStates(mergedColumns, true)),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      filterStates = _React$useState2[0],
+      setFilterStates = _React$useState2[1];
+
+  var mergedFilterStates = React.useMemo(function () {
+    var collectedStates = collectFilterStates(mergedColumns, false); // Return if not controlled
+
+    if (collectedStates.every(function (_ref5) {
+      var filteredKeys = _ref5.filteredKeys;
+      return filteredKeys === undefined;
+    })) {
+      return filterStates;
+    }
+
+    return collectedStates;
+  }, [mergedColumns, filterStates]);
+  var getFilters = React.useCallback(function () {
+    return generateFilterInfo(mergedFilterStates);
+  }, [mergedFilterStates]);
+
+  var triggerFilter = function triggerFilter(filterState) {
+    var newFilterStates = mergedFilterStates.filter(function (_ref6) {
+      var key = _ref6.key;
+      return key !== filterState.key;
+    });
+    newFilterStates.push(filterState);
+    setFilterStates(newFilterStates);
+    onFilterChange(generateFilterInfo(newFilterStates), newFilterStates);
+  };
+
+  var transformColumns = function transformColumns(innerColumns) {
+    return injectFilter(prefixCls, dropdownPrefixCls, innerColumns, mergedFilterStates, triggerFilter, getPopupContainer, tableLocale);
+  };
+
+  return [transformColumns, mergedFilterStates, getFilters];
+}
+
+export default useFilter;

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

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { GetRowKey } from '../interface';
+export default function useLazyKVMap<RecordType>(data: RecordType[], childrenColumnName: string, getRowKey: GetRowKey<RecordType>): ((key: React.ReactText) => RecordType)[];

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

@@ -0,0 +1,35 @@
+import * as React from 'react';
+export default function useLazyKVMap(data, childrenColumnName, getRowKey) {
+  var mapCacheRef = React.useRef({});
+
+  function getRecordByKey(key) {
+    if (!mapCacheRef.current || mapCacheRef.current.data !== data || mapCacheRef.current.childrenColumnName !== childrenColumnName || mapCacheRef.current.getRowKey !== getRowKey) {
+      /* eslint-disable no-inner-declarations */
+      var dig = function dig(records) {
+        records.forEach(function (record, index) {
+          var rowKey = getRowKey(record, index);
+          kvMap.set(rowKey, record);
+
+          if (childrenColumnName in record) {
+            dig(record[childrenColumnName] || []);
+          }
+        });
+      };
+      /* eslint-enable */
+
+
+      var kvMap = new Map();
+      dig(data);
+      mapCacheRef.current = {
+        data: data,
+        childrenColumnName: childrenColumnName,
+        kvMap: kvMap,
+        getRowKey: getRowKey
+      };
+    }
+
+    return mapCacheRef.current.kvMap.get(key);
+  }
+
+  return [getRecordByKey];
+}

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

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

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

@@ -0,0 +1,123 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+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';
+export var DEFAULT_PAGE_SIZE = 10;
+export function getPaginationParam(pagination, mergedPagination) {
+  var param = {
+    current: mergedPagination.current,
+    pageSize: mergedPagination.pageSize
+  };
+  var paginationObj = pagination && _typeof(pagination) === 'object' ? pagination : {};
+  Object.keys(paginationObj).forEach(function (pageProp) {
+    var value = mergedPagination[pageProp];
+
+    if (typeof value !== 'function') {
+      param[pageProp] = value;
+    }
+  });
+  return param;
+}
+export default function usePagination(total, pagination, onChange) {
+  var _a = pagination && _typeof(pagination) === 'object' ? pagination : {},
+      _a$total = _a.total,
+      paginationTotal = _a$total === void 0 ? 0 : _a$total,
+      paginationObj = __rest(_a, ["total"]);
+
+  var _useState = useState(function () {
+    return {
+      current: 'defaultCurrent' in paginationObj ? paginationObj.defaultCurrent : 1,
+      pageSize: 'defaultPageSize' in paginationObj ? paginationObj.defaultPageSize : DEFAULT_PAGE_SIZE
+    };
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      innerPagination = _useState2[0],
+      setInnerPagination = _useState2[1]; // ============ Basic Pagination Config ============
+
+
+  var mergedPagination = _extends(_extends(_extends({}, innerPagination), paginationObj), {
+    total: paginationTotal > 0 ? paginationTotal : total
+  });
+
+  if (!paginationTotal) {
+    // Reset `current` if data length changed. Only reset when paginationObj do not have total
+    var maxPage = Math.ceil(total / mergedPagination.pageSize);
+
+    if (maxPage < mergedPagination.current) {
+      mergedPagination.current = 1;
+    }
+  }
+
+  var refreshPagination = function refreshPagination() {
+    var current = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    setInnerPagination(_extends(_extends({}, mergedPagination), {
+      current: current
+    }));
+  };
+
+  var onInternalChange = function onInternalChange() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var current = args[0];
+    refreshPagination(current);
+    onChange(current, args[1] || mergedPagination.pageSize);
+
+    if (pagination && pagination.onChange) {
+      pagination.onChange.apply(pagination, args);
+    }
+  };
+
+  var onInternalShowSizeChange = function onInternalShowSizeChange() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    var pageSize = args[1];
+    setInnerPagination(_extends(_extends({}, mergedPagination), {
+      current: 1,
+      pageSize: pageSize
+    }));
+    onChange(1, pageSize);
+
+    if (pagination && pagination.onShowSizeChange) {
+      pagination.onShowSizeChange.apply(pagination, args);
+    }
+  };
+
+  if (pagination === false) {
+    return [{}, function () {}];
+  }
+
+  return [_extends(_extends({}, mergedPagination), {
+    onChange: onInternalChange,
+    onShowSizeChange: onInternalShowSizeChange
+  }), refreshPagination];
+}

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

@@ -0,0 +1,17 @@
+import { TableRowSelection, Key, GetRowKey, TableLocale, TransformColumns, ExpandType, GetPopupContainer } from '../interface';
+export declare const SELECTION_ALL = "SELECT_ALL";
+export declare const SELECTION_INVERT = "SELECT_INVERT";
+interface UseSelectionConfig<RecordType> {
+    prefixCls: string;
+    pageData: RecordType[];
+    data: RecordType[];
+    getRowKey: GetRowKey<RecordType>;
+    getRecordByKey: (key: Key) => RecordType;
+    expandType: ExpandType;
+    childrenColumnName: string;
+    expandIconColumnIndex?: number;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+}
+export default function useSelection<RecordType>(rowSelection: TableRowSelection<RecordType> | undefined, config: UseSelectionConfig<RecordType>): [TransformColumns<RecordType>, Set<Key>];
+export {};

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

@@ -0,0 +1,421 @@
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) 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 DownOutlined from '@ant-design/icons/DownOutlined';
+import Checkbox from '../../checkbox';
+import Dropdown from '../../dropdown';
+import Menu from '../../menu';
+import Radio from '../../radio';
+import warning from '../../_util/warning';
+var EMPTY_LIST = []; // TODO: warning if use ajax!!!
+
+export var SELECTION_ALL = 'SELECT_ALL';
+export var SELECTION_INVERT = 'SELECT_INVERT';
+
+function getFixedType(column) {
+  return column && column.fixed;
+}
+
+function flattenData(data, childrenColumnName) {
+  var list = [];
+  (data || []).forEach(function (record) {
+    list.push(record);
+
+    if (childrenColumnName in record) {
+      list = [].concat(_toConsumableArray(list), _toConsumableArray(flattenData(record[childrenColumnName], childrenColumnName)));
+    }
+  });
+  return list;
+}
+
+export default function useSelection(rowSelection, config) {
+  var _ref = rowSelection || {},
+      selectedRowKeys = _ref.selectedRowKeys,
+      getCheckboxProps = _ref.getCheckboxProps,
+      onSelectionChange = _ref.onChange,
+      onSelect = _ref.onSelect,
+      onSelectAll = _ref.onSelectAll,
+      onSelectInvert = _ref.onSelectInvert,
+      onSelectMultiple = _ref.onSelectMultiple,
+      _ref$columnWidth = _ref.columnWidth,
+      selectionColWidth = _ref$columnWidth === void 0 ? 60 : _ref$columnWidth,
+      selectionType = _ref.type,
+      selections = _ref.selections,
+      fixed = _ref.fixed,
+      customizeRenderCell = _ref.renderCell;
+
+  var prefixCls = config.prefixCls,
+      data = config.data,
+      pageData = config.pageData,
+      getRecordByKey = config.getRecordByKey,
+      getRowKey = config.getRowKey,
+      expandType = config.expandType,
+      childrenColumnName = config.childrenColumnName,
+      tableLocale = config.locale,
+      expandIconColumnIndex = config.expandIconColumnIndex,
+      getPopupContainer = config.getPopupContainer;
+
+  var _React$useState = React.useState(),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      innerSelectedKeys = _React$useState2[0],
+      setInnerSelectedKeys = _React$useState2[1];
+
+  var mergedSelectedKeys = selectedRowKeys || innerSelectedKeys || EMPTY_LIST;
+  var mergedSelectedKeySet = React.useMemo(function () {
+    var keys = selectionType === 'radio' ? mergedSelectedKeys.slice(0, 1) : mergedSelectedKeys;
+    return new Set(keys);
+  }, [mergedSelectedKeys, selectionType]); // Save last selected key to enable range selection
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      lastSelectedKey = _React$useState4[0],
+      setLastSelectedKey = _React$useState4[1]; // Reset if rowSelection reset
+
+
+  React.useEffect(function () {
+    if (!rowSelection) {
+      setInnerSelectedKeys([]);
+    }
+  }, [!!rowSelection]);
+  var setSelectedKeys = React.useCallback(function (keys) {
+    setInnerSelectedKeys(keys);
+    var records = keys.map(function (key) {
+      return getRecordByKey(key);
+    });
+
+    if (onSelectionChange) {
+      onSelectionChange(keys, records);
+    }
+  }, [setInnerSelectedKeys, getRecordByKey, onSelectionChange]); // Trigger single `onSelect` event
+
+  var triggerSingleSelection = React.useCallback(function (key, selected, keys, event) {
+    if (onSelect) {
+      var rows = keys.map(function (k) {
+        return getRecordByKey(k);
+      });
+      onSelect(getRecordByKey(key), selected, rows, event);
+    }
+
+    setSelectedKeys(keys);
+  }, [onSelect, getRecordByKey, setSelectedKeys]);
+  var mergedSelections = React.useMemo(function () {
+    if (!selections) {
+      return null;
+    }
+
+    var selectionList = selections === true ? [SELECTION_ALL, SELECTION_INVERT] : selections;
+    return selectionList.map(function (selection) {
+      if (selection === SELECTION_ALL) {
+        return {
+          key: 'all',
+          text: tableLocale.selectionAll,
+          onSelect: function onSelect() {
+            setSelectedKeys(data.map(function (record, index) {
+              return getRowKey(record, index);
+            }));
+          }
+        };
+      }
+
+      if (selection === SELECTION_INVERT) {
+        return {
+          key: 'invert',
+          text: tableLocale.selectInvert,
+          onSelect: function onSelect() {
+            var keySet = new Set(mergedSelectedKeySet);
+            pageData.forEach(function (record, index) {
+              var key = getRowKey(record, index);
+
+              if (keySet.has(key)) {
+                keySet["delete"](key);
+              } else {
+                keySet.add(key);
+              }
+            });
+            var keys = Array.from(keySet);
+            setSelectedKeys(keys);
+
+            if (onSelectInvert) {
+              warning(false, 'Table', '`onSelectInvert` will be removed in future. Please use `onChange` instead.');
+              onSelectInvert(keys);
+            }
+          }
+        };
+      }
+
+      return selection;
+    });
+  }, [selections, mergedSelectedKeySet, pageData, getRowKey]);
+  var transformColumns = React.useCallback(function (columns) {
+    if (!rowSelection) {
+      return columns;
+    } // Get flatten data
+
+
+    var flattedData = flattenData(pageData, childrenColumnName); // Support selection
+
+    var keySet = new Set(mergedSelectedKeySet); // Get all checkbox props
+
+    var checkboxPropsMap = new Map();
+    flattedData.forEach(function (record, index) {
+      var key = getRowKey(record, index);
+      var checkboxProps = (getCheckboxProps ? getCheckboxProps(record) : null) || {};
+      checkboxPropsMap.set(key, checkboxProps);
+
+      if (process.env.NODE_ENV !== 'production' && ('checked' in checkboxProps || 'defaultChecked' in checkboxProps)) {
+        warning(false, 'Table', 'Do not set `checked` or `defaultChecked` in `getCheckboxProps`. Please use `selectedRowKeys` instead.');
+      }
+    }); // Record key only need check with enabled
+
+    var recordKeys = flattedData.map(getRowKey).filter(function (key) {
+      return !checkboxPropsMap.get(key).disabled;
+    });
+    var checkedCurrentAll = recordKeys.every(function (key) {
+      return keySet.has(key);
+    });
+    var checkedCurrentSome = recordKeys.some(function (key) {
+      return keySet.has(key);
+    });
+
+    var onSelectAllChange = function onSelectAllChange() {
+      var changeKeys = [];
+
+      if (checkedCurrentAll) {
+        recordKeys.forEach(function (key) {
+          keySet["delete"](key);
+          changeKeys.push(key);
+        });
+      } else {
+        recordKeys.forEach(function (key) {
+          keySet.add(key);
+          changeKeys.push(key);
+        });
+      }
+
+      var keys = Array.from(keySet);
+      setSelectedKeys(keys);
+
+      if (onSelectAll) {
+        onSelectAll(!checkedCurrentAll, keys.map(function (k) {
+          return getRecordByKey(k);
+        }), changeKeys.map(function (k) {
+          return getRecordByKey(k);
+        }));
+      }
+    }; // ===================== Render =====================
+    // Title Cell
+
+
+    var title;
+
+    if (selectionType !== 'radio') {
+      var customizeSelections;
+
+      if (mergedSelections) {
+        var menu = /*#__PURE__*/React.createElement(Menu, {
+          getPopupContainer: getPopupContainer
+        }, mergedSelections.map(function (selection, index) {
+          var key = selection.key,
+              text = selection.text,
+              onSelectionClick = selection.onSelect;
+          return /*#__PURE__*/React.createElement(Menu.Item, {
+            key: key || index,
+            onClick: function onClick() {
+              if (onSelectionClick) {
+                onSelectionClick(recordKeys);
+              }
+            }
+          }, text);
+        }));
+        customizeSelections = /*#__PURE__*/React.createElement("div", {
+          className: "".concat(prefixCls, "-selection-extra")
+        }, /*#__PURE__*/React.createElement(Dropdown, {
+          overlay: menu,
+          getPopupContainer: getPopupContainer
+        }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(DownOutlined, null))));
+      }
+
+      var allDisabled = flattedData.every(function (record, index) {
+        var key = getRowKey(record, index);
+        var checkboxProps = checkboxPropsMap.get(key) || {};
+        return checkboxProps.disabled;
+      });
+      title = /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-selection")
+      }, /*#__PURE__*/React.createElement(Checkbox, {
+        checked: !allDisabled && !!flattedData.length && checkedCurrentAll,
+        indeterminate: !checkedCurrentAll && checkedCurrentSome,
+        onChange: onSelectAllChange,
+        disabled: flattedData.length === 0 || allDisabled
+      }), customizeSelections);
+    } // Body Cell
+
+
+    var renderCell;
+
+    if (selectionType === 'radio') {
+      renderCell = function renderCell(_, record, index) {
+        var key = getRowKey(record, index);
+        var checked = keySet.has(key);
+        return {
+          node: /*#__PURE__*/React.createElement(Radio, _extends({}, checkboxPropsMap.get(key), {
+            checked: checked,
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            },
+            onChange: function onChange(event) {
+              if (!keySet.has(key)) {
+                triggerSingleSelection(key, true, [key], event.nativeEvent);
+              }
+            }
+          })),
+          checked: checked
+        };
+      };
+    } else {
+      renderCell = function renderCell(_, record, index) {
+        var key = getRowKey(record, index);
+        var checked = keySet.has(key); // Record checked
+
+        return {
+          node: /*#__PURE__*/React.createElement(Checkbox, _extends({}, checkboxPropsMap.get(key), {
+            checked: checked,
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            },
+            onChange: function onChange(_ref2) {
+              var nativeEvent = _ref2.nativeEvent;
+              var shiftKey = nativeEvent.shiftKey;
+              var startIndex = -1;
+              var endIndex = -1; // Get range of this
+
+              if (shiftKey) {
+                var pointKeys = new Set([lastSelectedKey, key]);
+                recordKeys.some(function (recordKey, recordIndex) {
+                  if (pointKeys.has(recordKey)) {
+                    if (startIndex === -1) {
+                      startIndex = recordIndex;
+                    } else {
+                      endIndex = recordIndex;
+                      return true;
+                    }
+                  }
+
+                  return false;
+                });
+              }
+
+              if (endIndex !== -1 && startIndex !== endIndex) {
+                // Batch update selections
+                var rangeKeys = recordKeys.slice(startIndex, endIndex + 1);
+                var changedKeys = [];
+
+                if (checked) {
+                  rangeKeys.forEach(function (recordKey) {
+                    if (keySet.has(recordKey)) {
+                      changedKeys.push(recordKey);
+                      keySet["delete"](recordKey);
+                    }
+                  });
+                } else {
+                  rangeKeys.forEach(function (recordKey) {
+                    if (!keySet.has(recordKey)) {
+                      changedKeys.push(recordKey);
+                      keySet.add(recordKey);
+                    }
+                  });
+                }
+
+                var keys = Array.from(keySet);
+                setSelectedKeys(keys);
+
+                if (onSelectMultiple) {
+                  onSelectMultiple(!checked, keys.map(function (recordKey) {
+                    return getRecordByKey(recordKey);
+                  }), changedKeys.map(function (recordKey) {
+                    return getRecordByKey(recordKey);
+                  }));
+                }
+              } else {
+                // Single record selected
+                if (checked) {
+                  keySet["delete"](key);
+                } else {
+                  keySet.add(key);
+                }
+
+                triggerSingleSelection(key, !checked, Array.from(keySet), nativeEvent);
+              }
+
+              setLastSelectedKey(key);
+            }
+          })),
+          checked: checked
+        };
+      };
+    }
+
+    var renderSelectionCell = function renderSelectionCell(_, record, index) {
+      var _renderCell = renderCell(_, record, index),
+          node = _renderCell.node,
+          checked = _renderCell.checked;
+
+      if (customizeRenderCell) {
+        return customizeRenderCell(checked, record, index, node);
+      }
+
+      return node;
+    }; // Columns
+
+
+    var selectionColumn = {
+      width: selectionColWidth,
+      className: "".concat(prefixCls, "-selection-column"),
+      title: rowSelection.columnTitle || title,
+      render: renderSelectionCell
+    };
+
+    if (expandType === 'row' && columns.length && !expandIconColumnIndex) {
+      var _columns = _toArray(columns),
+          expandColumn = _columns[0],
+          restColumns = _columns.slice(1);
+
+      var selectionFixed = fixed || getFixedType(restColumns[0]);
+
+      if (selectionFixed) {
+        expandColumn.fixed = selectionFixed;
+      }
+
+      return [expandColumn, _extends(_extends({}, selectionColumn), {
+        fixed: selectionFixed
+      })].concat(_toConsumableArray(restColumns));
+    }
+
+    return [_extends(_extends({}, selectionColumn), {
+      fixed: fixed || getFixedType(columns[0])
+    })].concat(_toConsumableArray(columns));
+  }, [getRowKey, pageData, rowSelection, innerSelectedKeys, mergedSelectedKeys, selectionColWidth, mergedSelections, expandType, lastSelectedKey, onSelectMultiple, triggerSingleSelection]);
+  return [transformColumns, mergedSelectedKeySet];
+}

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

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { TransformColumns, ColumnsType, Key, ColumnType, SortOrder, ColumnTitleProps, SorterResult, TableLocale } from '../interface';
+export interface SortState<RecordType> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    sortOrder: SortOrder | null;
+    multiplePriority: number | false;
+}
+export declare function getSortData<RecordType>(data: RecordType[], sortStates: SortState<RecordType>[], childrenColumnName: string): RecordType[];
+interface SorterConfig<RecordType> {
+    prefixCls: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    onSorterChange: (sorterResult: SorterResult<RecordType> | SorterResult<RecordType>[], sortStates: SortState<RecordType>[]) => void;
+    sortDirections: SortOrder[];
+    tableLocale?: TableLocale;
+    showSorterTooltip?: boolean;
+}
+export default function useFilterSorter<RecordType>({ prefixCls, columns, children, onSorterChange, sortDirections, tableLocale, showSorterTooltip, }: SorterConfig<RecordType>): [TransformColumns<RecordType>, SortState<RecordType>[], ColumnTitleProps<RecordType>, () => SorterResult<RecordType> | SorterResult<RecordType>[]];
+export {};

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

@@ -0,0 +1,367 @@
+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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) 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; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import { convertChildrenToColumns } from "rc-table/es/hooks/useColumns";
+import CaretDownOutlined from '@ant-design/icons/CaretDownOutlined';
+import CaretUpOutlined from '@ant-design/icons/CaretUpOutlined';
+import Tooltip from '../../tooltip';
+import { getColumnKey, getColumnPos, renderColumnTitle } from '../util';
+var ASCEND = 'ascend';
+var DESCEND = 'descend';
+
+function getMultiplePriority(column) {
+  if (_typeof(column.sorter) === 'object' && typeof column.sorter.multiple === 'number') {
+    return column.sorter.multiple;
+  }
+
+  return false;
+}
+
+function getSortFunction(sorter) {
+  if (typeof sorter === 'function') {
+    return sorter;
+  }
+
+  if (sorter && _typeof(sorter) === 'object' && sorter.compare) {
+    return sorter.compare;
+  }
+
+  return false;
+}
+
+function nextSortDirection(sortDirections, current) {
+  if (!current) {
+    return sortDirections[0];
+  }
+
+  return sortDirections[sortDirections.indexOf(current) + 1];
+}
+
+function collectSortStates(columns, init, pos) {
+  var sortStates = [];
+
+  function pushState(column, columnPos) {
+    sortStates.push({
+      column: column,
+      key: getColumnKey(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  }
+
+  (columns || []).forEach(function (column, index) {
+    var 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: column,
+          key: getColumnKey(column, columnPos),
+          multiplePriority: getMultiplePriority(column),
+          sortOrder: column.defaultSortOrder
+        });
+      }
+    }
+  });
+  return sortStates;
+}
+
+function injectSorter(prefixCls, columns, sorterSates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos) {
+  return (columns || []).map(function (column, index) {
+    var columnPos = getColumnPos(index, pos);
+    var newColumn = column;
+
+    if (newColumn.sorter) {
+      var sortDirections = newColumn.sortDirections || defaultSortDirections;
+      var showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      var columnKey = getColumnKey(newColumn, columnPos);
+      var sorterState = sorterSates.find(function (_ref) {
+        var key = _ref.key;
+        return key === columnKey;
+      });
+      var sorterOrder = sorterState ? sorterState.sortOrder : null;
+      var nextSortOrder = nextSortDirection(sortDirections, sorterOrder);
+      var upNode = sortDirections.includes(ASCEND) && /*#__PURE__*/React.createElement(CaretUpOutlined, {
+        className: classNames("".concat(prefixCls, "-column-sorter-up"), {
+          active: sorterOrder === ASCEND
+        })
+      });
+      var downNode = sortDirections.includes(DESCEND) && /*#__PURE__*/React.createElement(CaretDownOutlined, {
+        className: classNames("".concat(prefixCls, "-column-sorter-down"), {
+          active: sorterOrder === DESCEND
+        })
+      });
+
+      var _ref2 = tableLocale || {},
+          cancelSort = _ref2.cancelSort,
+          triggerAsc = _ref2.triggerAsc,
+          triggerDesc = _ref2.triggerDesc;
+
+      var sortTip = cancelSort;
+
+      if (nextSortOrder === DESCEND) {
+        sortTip = triggerDesc;
+      } else if (nextSortOrder === ASCEND) {
+        sortTip = triggerAsc;
+      }
+
+      newColumn = _extends(_extends({}, newColumn), {
+        className: classNames(newColumn.className, _defineProperty({}, "".concat(prefixCls, "-column-sort"), sorterOrder)),
+        title: function title(renderProps) {
+          var renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: "".concat(prefixCls, "-column-sorters")
+          }, /*#__PURE__*/React.createElement("span", null, renderColumnTitle(column.title, renderProps)), /*#__PURE__*/React.createElement("span", {
+            className: classNames("".concat(prefixCls, "-column-sorter"), _defineProperty({}, "".concat(prefixCls, "-column-sorter-full"), upNode && downNode))
+          }, /*#__PURE__*/React.createElement("span", {
+            className: "".concat(prefixCls, "-column-sorter-inner")
+          }, upNode, downNode)));
+          return showSorterTooltip ? /*#__PURE__*/React.createElement(Tooltip, {
+            title: sortTip
+          }, /*#__PURE__*/React.createElement("div", {
+            className: "".concat(prefixCls, "-column-sorters-with-tooltip")
+          }, renderSortTitle)) : renderSortTitle;
+        },
+        onHeaderCell: function onHeaderCell(col) {
+          var cell = column.onHeaderCell && column.onHeaderCell(col) || {};
+          var originOnClick = cell.onClick;
+
+          cell.onClick = function (event) {
+            triggerSorter({
+              column: column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+
+            if (originOnClick) {
+              originOnClick(event);
+            }
+          };
+
+          cell.className = classNames(cell.className, "".concat(prefixCls, "-column-has-sorters"));
+          return cell;
+        }
+      });
+    }
+
+    if ('children' in newColumn) {
+      newColumn = _extends(_extends({}, newColumn), {
+        children: injectSorter(prefixCls, newColumn.children, sorterSates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos)
+      });
+    }
+
+    return newColumn;
+  });
+}
+
+function stateToInfo(sorterStates) {
+  var column = sorterStates.column,
+      sortOrder = sorterStates.sortOrder;
+  return {
+    column: column,
+    order: sortOrder,
+    field: column.dataIndex,
+    columnKey: column.key
+  };
+}
+
+function generateSorterInfo(sorterStates) {
+  var list = sorterStates.filter(function (_ref3) {
+    var sortOrder = _ref3.sortOrder;
+    return sortOrder;
+  }).map(stateToInfo); // =========== Legacy compatible support ===========
+  // https://github.com/ant-design/ant-design/pull/19226
+
+  if (list.length === 0 && sorterStates.length) {
+    return _extends(_extends({}, stateToInfo(sorterStates[0])), {
+      column: undefined
+    });
+  }
+
+  if (list.length <= 1) {
+    return list[0] || {};
+  }
+
+  return list;
+}
+
+export function getSortData(data, sortStates, childrenColumnName) {
+  var innerSorterStates = sortStates.slice().sort(function (a, b) {
+    return b.multiplePriority - a.multiplePriority;
+  });
+  var cloneData = data.slice();
+  var runningSorters = innerSorterStates.filter(function (_ref4) {
+    var sorter = _ref4.column.sorter,
+        sortOrder = _ref4.sortOrder;
+    return getSortFunction(sorter) && sortOrder;
+  }); // Skip if no sorter needed
+
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+
+  return cloneData.sort(function (record1, record2) {
+    for (var i = 0; i < runningSorters.length; i += 1) {
+      var sorterState = runningSorters[i];
+      var sorter = sorterState.column.sorter,
+          sortOrder = sorterState.sortOrder;
+      var compareFn = getSortFunction(sorter);
+
+      if (compareFn && sortOrder) {
+        var compareResult = compareFn(record1, record2, sortOrder);
+
+        if (compareResult !== 0) {
+          return sortOrder === ASCEND ? compareResult : -compareResult;
+        }
+      }
+    }
+
+    return 0;
+  }).map(function (record) {
+    var subRecords = record[childrenColumnName];
+
+    if (subRecords) {
+      return _extends(_extends({}, record), _defineProperty({}, childrenColumnName, getSortData(subRecords, sortStates, childrenColumnName)));
+    }
+
+    return record;
+  });
+}
+export default function useFilterSorter(_ref5) {
+  var prefixCls = _ref5.prefixCls,
+      columns = _ref5.columns,
+      children = _ref5.children,
+      onSorterChange = _ref5.onSorterChange,
+      sortDirections = _ref5.sortDirections,
+      tableLocale = _ref5.tableLocale,
+      showSorterTooltip = _ref5.showSorterTooltip;
+  var mergedColumns = React.useMemo(function () {
+    return columns || convertChildrenToColumns(children);
+  }, [children, columns]);
+
+  var _React$useState = React.useState(collectSortStates(mergedColumns, true)),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      sortStates = _React$useState2[0],
+      setSortStates = _React$useState2[1];
+
+  var mergedSorterStates = React.useMemo(function () {
+    var validate = true;
+    var collectedStates = collectSortStates(mergedColumns, false); // Return if not controlled
+
+    if (!collectedStates.length) {
+      return sortStates;
+    }
+
+    var validateStates = [];
+
+    function patchStates(state) {
+      if (validate) {
+        validateStates.push(state);
+      } else {
+        validateStates.push(_extends(_extends({}, state), {
+          sortOrder: null
+        }));
+      }
+    }
+
+    var multipleMode = null;
+    collectedStates.forEach(function (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
+
+  var columnTitleSorterProps = React.useMemo(function () {
+    var sortColumns = mergedSorterStates.map(function (_ref6) {
+      var column = _ref6.column,
+          sortOrder = _ref6.sortOrder;
+      return {
+        column: column,
+        order: sortOrder
+      };
+    });
+    return {
+      sortColumns: sortColumns,
+      // Legacy
+      sortColumn: sortColumns[0] && sortColumns[0].column,
+      sortOrder: sortColumns[0] && sortColumns[0].order
+    };
+  }, [mergedSorterStates]);
+
+  function triggerSorter(sortState) {
+    var newSorterStates;
+
+    if (sortState.multiplePriority === false || !mergedSorterStates.length || mergedSorterStates[0].multiplePriority === false) {
+      newSorterStates = [sortState];
+    } else {
+      newSorterStates = [].concat(_toConsumableArray(mergedSorterStates.filter(function (_ref7) {
+        var key = _ref7.key;
+        return key !== sortState.key;
+      })), [sortState]);
+    }
+
+    setSortStates(newSorterStates);
+    onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+  }
+
+  var transformColumns = function transformColumns(innerColumns) {
+    return injectSorter(prefixCls, innerColumns, mergedSorterStates, triggerSorter, sortDirections, tableLocale, showSorterTooltip);
+  };
+
+  var getSorters = function getSorters() {
+    return generateSorterInfo(mergedSorterStates);
+  };
+
+  return [transformColumns, mergedSorterStates, columnTitleSorterProps, getSorters];
+}

web/node_modules/antd/es/table/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+declare type UseSyncStateProps<T> = [() => T, (newValue: T) => void];
+export default function useSyncState<T>(filteredKeys: T): UseSyncStateProps<T>;
+export {};

web/node_modules/antd/es/table/hooks/useSyncState.js

@@ -0,0 +1,28 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+export default function useSyncState(filteredKeys) {
+  var filteredKeysRef = React.useRef(filteredKeys);
+
+  var _React$useState = React.useState(null),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      forceUpdate = _React$useState2[1];
+
+  return [function () {
+    return filteredKeysRef.current;
+  }, function (newValue) {
+    filteredKeysRef.current = newValue; // re-render
+
+    forceUpdate({});
+  }];
+}

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

@@ -0,0 +1,2 @@
+import { TransformColumns, ColumnTitleProps } from '../interface';
+export default function useTitleColumns<RecordType>(columnTitleProps: ColumnTitleProps<RecordType>): [TransformColumns<RecordType>];

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

@@ -0,0 +1,25 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import * as React from 'react';
+import { renderColumnTitle } from '../util';
+
+function fillTitle(columns, columnTitleProps) {
+  return columns.map(function (column) {
+    var cloneColumn = _extends({}, column);
+
+    cloneColumn.title = renderColumnTitle(column.title, columnTitleProps);
+
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+
+    return cloneColumn;
+  });
+}
+
+export default function useTitleColumns(columnTitleProps) {
+  var filledColumns = React.useCallback(function (columns) {
+    return fillTitle(columns, columnTitleProps);
+  }, [columnTitleProps]);
+  return [filledColumns];
+}