Latest updates from IceHrmPro

web/node_modules/antd/lib/table/Column.d.ts

@@ -0,0 +1,10 @@
+import { ColumnType } from './interface';
+export interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function Column<RecordType>(_: ColumnProps<RecordType>): null;
+export default Column;

web/node_modules/antd/lib/table/Column.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+/* istanbul ignore next */
+
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line no-unused-vars
+function Column(_) {
+  return null;
+}
+
+var _default = Column;
+exports["default"] = _default;

web/node_modules/antd/lib/table/ColumnGroup.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { ColumnType } from './interface';
+import { ColumnProps } from './Column';
+export interface ColumnGroupProps<RecordType> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | React.ReactElement<ColumnProps<RecordType>>[];
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): null;
+export default ColumnGroup;

web/node_modules/antd/lib/table/ColumnGroup.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+/* istanbul ignore next */
+
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line no-unused-vars
+function ColumnGroup(_) {
+  return null;
+}
+
+var _default = ColumnGroup;
+exports["default"] = _default;

web/node_modules/antd/lib/table/ExpandIcon.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { TableLocale } from './interface';
+interface DefaultExpandIconProps<RecordType> {
+    prefixCls: string;
+    onExpand: (record: RecordType, e: React.MouseEvent<HTMLElement>) => void;
+    record: RecordType;
+    expanded: boolean;
+    expandable: boolean;
+}
+declare function renderExpandIcon(locale: TableLocale): <RecordType>({ prefixCls, onExpand, record, expanded, expandable, }: DefaultExpandIconProps<RecordType>) => JSX.Element;
+export default renderExpandIcon;

web/node_modules/antd/lib/table/ExpandIcon.js

@@ -0,0 +1,45 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 renderExpandIcon(locale) {
+  return function expandIcon(_ref) {
+    var _classNames;
+
+    var prefixCls = _ref.prefixCls,
+        onExpand = _ref.onExpand,
+        record = _ref.record,
+        expanded = _ref.expanded,
+        expandable = _ref.expandable;
+    var iconPrefix = "".concat(prefixCls, "-row-expand-icon");
+    return /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: function onClick(e) {
+        onExpand(record, e);
+        e.stopPropagation();
+      },
+      className: (0, _classnames["default"])(iconPrefix, (_classNames = {}, _defineProperty(_classNames, "".concat(iconPrefix, "-spaced"), !expandable), _defineProperty(_classNames, "".concat(iconPrefix, "-expanded"), expandable && expanded), _defineProperty(_classNames, "".concat(iconPrefix, "-collapsed"), expandable && !expanded), _classNames)),
+      "aria-label": expanded ? locale.collapse : locale.expand
+    });
+  };
+}
+
+var _default = renderExpandIcon;
+exports["default"] = _default;

web/node_modules/antd/lib/table/Table.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import { TableProps as RcTableProps } from 'rc-table/lib/Table';
+import { SpinProps } from '../spin';
+import { PaginationConfig } from '../pagination';
+import { TableRowSelection, ColumnsType, TableCurrentDataSource, SorterResult, Key, GetPopupContainer, TablePaginationConfig, SortOrder, TableLocale } from './interface';
+import { SizeType } from '../config-provider/SizeContext';
+export { ColumnsType, TablePaginationConfig };
+export interface TableProps<RecordType> extends Omit<RcTableProps<RecordType>, 'transformColumns' | 'internalHooks' | 'internalRefs' | 'data' | 'columns' | 'scroll'> {
+    dropdownPrefixCls?: string;
+    dataSource?: RcTableProps<RecordType>['data'];
+    columns?: ColumnsType<RecordType>;
+    pagination?: false | TablePaginationConfig;
+    loading?: boolean | SpinProps;
+    size?: SizeType;
+    bordered?: boolean;
+    locale?: TableLocale;
+    onChange?: (pagination: PaginationConfig, filters: Record<string, Key[] | null>, sorter: SorterResult<RecordType> | SorterResult<RecordType>[], extra: TableCurrentDataSource<RecordType>) => void;
+    rowSelection?: TableRowSelection<RecordType>;
+    getPopupContainer?: GetPopupContainer;
+    scroll?: RcTableProps<RecordType>['scroll'] & {
+        scrollToFirstRowOnChange?: boolean;
+    };
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean;
+}
+declare function Table<RecordType extends object = any>(props: TableProps<RecordType>): JSX.Element;
+declare namespace Table {
+    var defaultProps: {
+        rowKey: string;
+    };
+    var SELECTION_ALL: string;
+    var SELECTION_INVERT: string;
+    var Column: typeof import("./Column").default;
+    var ColumnGroup: typeof import("./ColumnGroup").default;
+}
+export default Table;

web/node_modules/antd/lib/table/Table.js

@@ -0,0 +1,446 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _omit = _interopRequireDefault(require("omit.js"));
+
+var _rcTable = _interopRequireDefault(require("rc-table"));
+
+var _Table = require("rc-table/lib/Table");
+
+var _spin = _interopRequireDefault(require("../spin"));
+
+var _pagination = _interopRequireDefault(require("../pagination"));
+
+var _context = require("../config-provider/context");
+
+var _usePagination3 = _interopRequireWildcard(require("./hooks/usePagination"));
+
+var _useLazyKVMap3 = _interopRequireDefault(require("./hooks/useLazyKVMap"));
+
+var _useSelection3 = _interopRequireWildcard(require("./hooks/useSelection"));
+
+var _useSorter3 = _interopRequireWildcard(require("./hooks/useSorter"));
+
+var _useFilter3 = _interopRequireWildcard(require("./hooks/useFilter"));
+
+var _useTitleColumns3 = _interopRequireDefault(require("./hooks/useTitleColumns"));
+
+var _ExpandIcon = _interopRequireDefault(require("./ExpandIcon"));
+
+var _scrollTo = _interopRequireDefault(require("../_util/scrollTo"));
+
+var _en_US = _interopRequireDefault(require("../locale/en_US"));
+
+var _SizeContext = _interopRequireDefault(require("../config-provider/SizeContext"));
+
+var _Column = _interopRequireDefault(require("./Column"));
+
+var _ColumnGroup = _interopRequireDefault(require("./ColumnGroup"));
+
+var _warning = _interopRequireDefault(require("../_util/warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }
+
+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; }
+
+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); }
+
+var EMPTY_LIST = [];
+
+function Table(props) {
+  var _classNames3;
+
+  var customizePrefixCls = props.prefixCls,
+      className = props.className,
+      style = props.style,
+      customizeSize = props.size,
+      bordered = props.bordered,
+      customizeDropdownPrefixCls = props.dropdownPrefixCls,
+      dataSource = props.dataSource,
+      pagination = props.pagination,
+      rowSelection = props.rowSelection,
+      rowKey = props.rowKey,
+      rowClassName = props.rowClassName,
+      columns = props.columns,
+      children = props.children,
+      legacyChildrenColumnName = props.childrenColumnName,
+      onChange = props.onChange,
+      getPopupContainer = props.getPopupContainer,
+      loading = props.loading,
+      expandIcon = props.expandIcon,
+      expandable = props.expandable,
+      expandedRowRender = props.expandedRowRender,
+      expandIconColumnIndex = props.expandIconColumnIndex,
+      indentSize = props.indentSize,
+      scroll = props.scroll,
+      sortDirections = props.sortDirections,
+      locale = props.locale,
+      _props$showSorterTool = props.showSorterTooltip,
+      showSorterTooltip = _props$showSorterTool === void 0 ? true : _props$showSorterTool;
+  var tableProps = (0, _omit["default"])(props, ['className', 'style']);
+  var size = React.useContext(_SizeContext["default"]);
+
+  var _React$useContext = React.useContext(_context.ConfigContext),
+      _React$useContext$loc = _React$useContext.locale,
+      contextLocale = _React$useContext$loc === void 0 ? _en_US["default"] : _React$useContext$loc,
+      renderEmpty = _React$useContext.renderEmpty,
+      direction = _React$useContext.direction;
+
+  var mergedSize = customizeSize || size;
+
+  var tableLocale = _extends(_extends({}, contextLocale.Table), locale);
+
+  var rawData = dataSource || EMPTY_LIST;
+
+  var _React$useContext2 = React.useContext(_context.ConfigContext),
+      getPrefixCls = _React$useContext2.getPrefixCls;
+
+  var prefixCls = getPrefixCls('table', customizePrefixCls);
+  var dropdownPrefixCls = getPrefixCls('dropdown', customizeDropdownPrefixCls);
+
+  var mergedExpandable = _extends({
+    childrenColumnName: legacyChildrenColumnName,
+    expandIconColumnIndex: expandIconColumnIndex
+  }, expandable);
+
+  var _mergedExpandable$chi = mergedExpandable.childrenColumnName,
+      childrenColumnName = _mergedExpandable$chi === void 0 ? 'children' : _mergedExpandable$chi;
+  var expandType = React.useMemo(function () {
+    if (rawData.some(function (item) {
+      return item[childrenColumnName];
+    })) {
+      return 'nest';
+    }
+
+    if (expandedRowRender || expandable && expandable.expandedRowRender) {
+      return 'row';
+    }
+
+    return null;
+  }, [rawData]);
+  var internalRefs = {
+    body: React.useRef()
+  }; // ============================ RowKey ============================
+
+  var getRowKey = React.useMemo(function () {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+
+    return function (record) {
+      return record[rowKey];
+    };
+  }, [rowKey]);
+
+  var _useLazyKVMap = (0, _useLazyKVMap3["default"])(rawData, childrenColumnName, getRowKey),
+      _useLazyKVMap2 = _slicedToArray(_useLazyKVMap, 1),
+      getRecordByKey = _useLazyKVMap2[0]; // ============================ Events =============================
+
+
+  var changeEventInfo = {};
+
+  var triggerOnChange = function triggerOnChange(info) {
+    var reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    var changeInfo = _extends(_extends({}, changeEventInfo), info);
+
+    if (reset) {
+      changeEventInfo.resetPagination(); // Reset event param
+
+      if (changeInfo.pagination.current) {
+        changeInfo.pagination.current = 1;
+      } // Trigger pagination events
+
+
+      if (pagination && pagination.onChange) {
+        pagination.onChange(1, changeInfo.pagination.pageSize);
+      }
+    }
+
+    if (scroll && scroll.scrollToFirstRowOnChange !== false && internalRefs.body.current) {
+      (0, _scrollTo["default"])(0, {
+        getContainer: function getContainer() {
+          return internalRefs.body.current;
+        }
+      });
+    }
+
+    if (onChange) {
+      onChange(changeInfo.pagination, changeInfo.filters, changeInfo.sorter, {
+        currentDataSource: (0, _useFilter3.getFilterData)((0, _useSorter3.getSortData)(rawData, changeInfo.sorterStates, childrenColumnName), changeInfo.filterStates)
+      });
+    }
+  };
+  /**
+   * Controlled state in `columns` is not a good idea that makes too many code (1000+ line?)
+   * to read state out and then put it back to title render.
+   * Move these code into `hooks` but still too complex.
+   * We should provides Table props like `sorter` & `filter` to handle control in next big version.
+   */
+  // ============================ Sorter =============================
+
+
+  var onSorterChange = function onSorterChange(sorter, sorterStates) {
+    triggerOnChange({
+      sorter: sorter,
+      sorterStates: sorterStates
+    }, false);
+  };
+
+  var _useSorter = (0, _useSorter3["default"])({
+    prefixCls: prefixCls,
+    columns: columns,
+    children: children,
+    onSorterChange: onSorterChange,
+    sortDirections: sortDirections || ['ascend', 'descend'],
+    tableLocale: tableLocale,
+    showSorterTooltip: showSorterTooltip
+  }),
+      _useSorter2 = _slicedToArray(_useSorter, 4),
+      transformSorterColumns = _useSorter2[0],
+      sortStates = _useSorter2[1],
+      sorterTitleProps = _useSorter2[2],
+      getSorters = _useSorter2[3];
+
+  var sortedData = React.useMemo(function () {
+    return (0, _useSorter3.getSortData)(rawData, sortStates, childrenColumnName);
+  }, [rawData, sortStates]);
+  changeEventInfo.sorter = getSorters();
+  changeEventInfo.sorterStates = sortStates; // ============================ Filter ============================
+
+  var onFilterChange = function onFilterChange(filters, filterStates) {
+    triggerOnChange({
+      filters: filters,
+      filterStates: filterStates
+    }, true);
+  };
+
+  var _useFilter = (0, _useFilter3["default"])({
+    prefixCls: prefixCls,
+    locale: tableLocale,
+    dropdownPrefixCls: dropdownPrefixCls,
+    columns: columns,
+    children: children,
+    onFilterChange: onFilterChange,
+    getPopupContainer: getPopupContainer
+  }),
+      _useFilter2 = _slicedToArray(_useFilter, 3),
+      transformFilterColumns = _useFilter2[0],
+      filterStates = _useFilter2[1],
+      getFilters = _useFilter2[2];
+
+  var mergedData = (0, _useFilter3.getFilterData)(sortedData, filterStates);
+  changeEventInfo.filters = getFilters();
+  changeEventInfo.filterStates = filterStates; // ============================ Column ============================
+
+  var columnTitleProps = React.useMemo(function () {
+    return _extends({}, sorterTitleProps);
+  }, [sorterTitleProps]);
+
+  var _useTitleColumns = (0, _useTitleColumns3["default"])(columnTitleProps),
+      _useTitleColumns2 = _slicedToArray(_useTitleColumns, 1),
+      transformTitleColumns = _useTitleColumns2[0]; // ========================== Pagination ==========================
+
+
+  var onPaginationChange = function onPaginationChange(current, pageSize) {
+    triggerOnChange({
+      pagination: _extends(_extends({}, changeEventInfo.pagination), {
+        current: current,
+        pageSize: pageSize
+      })
+    });
+  };
+
+  var _usePagination = (0, _usePagination3["default"])(mergedData.length, pagination, onPaginationChange),
+      _usePagination2 = _slicedToArray(_usePagination, 2),
+      mergedPagination = _usePagination2[0],
+      resetPagination = _usePagination2[1];
+
+  changeEventInfo.pagination = pagination === false ? {} : (0, _usePagination3.getPaginationParam)(pagination, mergedPagination);
+  changeEventInfo.resetPagination = resetPagination; // ============================= Data =============================
+
+  var pageData = React.useMemo(function () {
+    if (pagination === false || !mergedPagination.pageSize) {
+      return mergedData;
+    }
+
+    var _mergedPagination$cur = mergedPagination.current,
+        current = _mergedPagination$cur === void 0 ? 1 : _mergedPagination$cur,
+        total = mergedPagination.total,
+        _mergedPagination$pag = mergedPagination.pageSize,
+        pageSize = _mergedPagination$pag === void 0 ? _usePagination3.DEFAULT_PAGE_SIZE : _mergedPagination$pag; // Dynamic table data
+
+    if (mergedData.length < total) {
+      if (mergedData.length > pageSize) {
+        (0, _warning["default"])(false, 'Table', '`dataSource` length is less than `pagination.total` but large than `pagination.pageSize`. Please make sure your config correct data with async mode.');
+        return mergedData.slice((current - 1) * pageSize, current * pageSize);
+      }
+
+      return mergedData;
+    }
+
+    var currentPageData = mergedData.slice((current - 1) * pageSize, current * pageSize);
+    return currentPageData;
+  }, [!!pagination, mergedData, mergedPagination && mergedPagination.current, mergedPagination && mergedPagination.pageSize, mergedPagination && mergedPagination.total]); // ========================== Selections ==========================
+
+  var _useSelection = (0, _useSelection3["default"])(rowSelection, {
+    prefixCls: prefixCls,
+    data: mergedData,
+    pageData: pageData,
+    getRowKey: getRowKey,
+    getRecordByKey: getRecordByKey,
+    expandType: expandType,
+    childrenColumnName: childrenColumnName,
+    locale: tableLocale,
+    expandIconColumnIndex: mergedExpandable.expandIconColumnIndex,
+    getPopupContainer: getPopupContainer
+  }),
+      _useSelection2 = _slicedToArray(_useSelection, 2),
+      transformSelectionColumns = _useSelection2[0],
+      selectedKeySet = _useSelection2[1];
+
+  var internalRowClassName = function internalRowClassName(record, index, indent) {
+    var mergedRowClassName;
+
+    if (typeof rowClassName === 'function') {
+      mergedRowClassName = (0, _classnames["default"])(rowClassName(record, index, indent));
+    } else {
+      mergedRowClassName = (0, _classnames["default"])(rowClassName);
+    }
+
+    return (0, _classnames["default"])(_defineProperty({}, "".concat(prefixCls, "-row-selected"), selectedKeySet.has(getRowKey(record, index))), mergedRowClassName);
+  }; // ========================== Expandable ==========================
+  // Pass origin render status into `rc-table`, this can be removed when refactor with `rc-table`
+
+
+  mergedExpandable.__PARENT_RENDER_ICON__ = mergedExpandable.expandIcon; // Customize expandable icon
+
+  mergedExpandable.expandIcon = mergedExpandable.expandIcon || expandIcon || (0, _ExpandIcon["default"])(tableLocale); // Adjust expand icon index, no overwrite expandIconColumnIndex if set.
+
+  if (expandType === 'nest' && mergedExpandable.expandIconColumnIndex === undefined) {
+    mergedExpandable.expandIconColumnIndex = rowSelection ? 1 : 0;
+  } else if (mergedExpandable.expandIconColumnIndex > 0 && rowSelection) {
+    mergedExpandable.expandIconColumnIndex -= 1;
+  } // Indent size
+
+
+  mergedExpandable.indentSize = mergedExpandable.indentSize || indentSize || 15; // ============================ Render ============================
+
+  var transformColumns = React.useCallback(function (innerColumns) {
+    return transformTitleColumns(transformSelectionColumns(transformFilterColumns(transformSorterColumns(innerColumns))));
+  }, [transformSorterColumns, transformFilterColumns, transformSelectionColumns]);
+  var topPaginationNode;
+  var bottomPaginationNode;
+
+  if (pagination !== false) {
+    var paginationSize;
+
+    if (mergedPagination.size) {
+      paginationSize = mergedPagination.size;
+    } else {
+      paginationSize = mergedSize === 'small' || mergedSize === 'middle' ? 'small' : undefined;
+    }
+
+    var renderPagination = function renderPagination() {
+      var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'right';
+      return /*#__PURE__*/React.createElement(_pagination["default"], _extends({
+        className: "".concat(prefixCls, "-pagination ").concat(prefixCls, "-pagination-").concat(position)
+      }, mergedPagination, {
+        size: paginationSize
+      }));
+    };
+
+    if (mergedPagination.position !== null && Array.isArray(mergedPagination.position)) {
+      var topPos = mergedPagination.position.find(function (p) {
+        return p.indexOf('top') !== -1;
+      });
+      var bottomPos = mergedPagination.position.find(function (p) {
+        return p.indexOf('bottom') !== -1;
+      });
+
+      if (!topPos && !bottomPos) {
+        bottomPaginationNode = renderPagination();
+      } else {
+        if (topPos) {
+          topPaginationNode = renderPagination(topPos.toLowerCase().replace('top', ''));
+        }
+
+        if (bottomPos) {
+          bottomPaginationNode = renderPagination(bottomPos.toLowerCase().replace('bottom', ''));
+        }
+      }
+    } else {
+      bottomPaginationNode = renderPagination();
+    }
+  } // >>>>>>>>> Spinning
+
+
+  var spinProps;
+
+  if (typeof loading === 'boolean') {
+    spinProps = {
+      spinning: loading
+    };
+  } else if (_typeof(loading) === 'object') {
+    spinProps = _extends({
+      spinning: true
+    }, loading);
+  }
+
+  var wrapperClassNames = (0, _classnames["default"])("".concat(prefixCls, "-wrapper"), className, _defineProperty({}, "".concat(prefixCls, "-wrapper-rtl"), direction === 'rtl'));
+  return /*#__PURE__*/React.createElement("div", {
+    className: wrapperClassNames,
+    style: style
+  }, /*#__PURE__*/React.createElement(_spin["default"], _extends({
+    spinning: false
+  }, spinProps), topPaginationNode, /*#__PURE__*/React.createElement(_rcTable["default"], _extends({}, tableProps, {
+    direction: direction,
+    expandable: mergedExpandable,
+    prefixCls: prefixCls,
+    className: (0, _classnames["default"])((_classNames3 = {}, _defineProperty(_classNames3, "".concat(prefixCls, "-middle"), mergedSize === 'middle'), _defineProperty(_classNames3, "".concat(prefixCls, "-small"), mergedSize === 'small'), _defineProperty(_classNames3, "".concat(prefixCls, "-bordered"), bordered), _classNames3)),
+    data: pageData,
+    rowKey: getRowKey,
+    rowClassName: internalRowClassName,
+    emptyText: locale && locale.emptyText || renderEmpty('Table') // Internal
+    ,
+    internalHooks: _Table.INTERNAL_HOOKS,
+    internalRefs: internalRefs,
+    transformColumns: transformColumns
+  })), pageData && pageData.length > 0 && bottomPaginationNode));
+}
+
+Table.defaultProps = {
+  rowKey: 'key'
+};
+Table.SELECTION_ALL = _useSelection3.SELECTION_ALL;
+Table.SELECTION_INVERT = _useSelection3.SELECTION_INVERT;
+Table.Column = _Column["default"];
+Table.ColumnGroup = _ColumnGroup["default"];
+var _default = Table;
+exports["default"] = _default;

web/node_modules/antd/lib/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/lib/table/hooks/useFilter/FilterDropdown.js

@@ -0,0 +1,277 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _FilterFilled = _interopRequireDefault(require("@ant-design/icons/FilterFilled"));
+
+var _button = _interopRequireDefault(require("../../../button"));
+
+var _menu = _interopRequireDefault(require("../../../menu"));
+
+var _checkbox = _interopRequireDefault(require("../../../checkbox"));
+
+var _radio = _interopRequireDefault(require("../../../radio"));
+
+var _dropdown = _interopRequireDefault(require("../../../dropdown"));
+
+var _FilterWrapper = _interopRequireDefault(require("./FilterWrapper"));
+
+var _useSyncState3 = _interopRequireDefault(require("../useSyncState"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+var SubMenu = _menu["default"].SubMenu,
+    MenuItem = _menu["default"].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["default"] : _radio["default"];
+    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 = (0, _useSyncState3["default"])(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 ((0, _isEqual["default"])(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 = (0, _classnames["default"])(_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["default"], {
+      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["default"], {
+      type: "link",
+      size: "small",
+      disabled: selectedKeys.length === 0,
+      onClick: onReset
+    }, locale.filterReset), /*#__PURE__*/React.createElement(_button["default"], {
+      type: "primary",
+      size: "small",
+      onClick: onConfirm
+    }, locale.filterConfirm)));
+  }
+
+  var menu = /*#__PURE__*/React.createElement(_FilterWrapper["default"], {
+    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["default"], null);
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: (0, _classnames["default"])("".concat(prefixCls, "-column"))
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-column-title")
+  }, children), /*#__PURE__*/React.createElement("span", {
+    className: (0, _classnames["default"])("".concat(prefixCls, "-trigger-container"), _defineProperty({}, "".concat(prefixCls, "-trigger-container-open"), mergedVisible)),
+    onClick: function onClick(e) {
+      e.stopPropagation();
+    }
+  }, /*#__PURE__*/React.createElement(_dropdown["default"], {
+    overlay: menu,
+    trigger: ['click'],
+    visible: mergedVisible,
+    onVisibleChange: onVisibleChange,
+    getPopupContainer: getPopupContainer,
+    placement: "bottomRight"
+  }, /*#__PURE__*/React.createElement("span", {
+    role: "button",
+    tabIndex: -1,
+    className: (0, _classnames["default"])("".concat(prefixCls, "-trigger"), {
+      active: filtered
+    })
+  }, filterIcon))));
+}
+
+var _default = FilterDropdown;
+exports["default"] = _default;

web/node_modules/antd/lib/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/lib/table/hooks/useFilter/FilterWrapper.js

@@ -0,0 +1,26 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var FilterDropdownMenuWrapper = function FilterDropdownMenuWrapper(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    }
+  }, props.children);
+};
+
+var _default = FilterDropdownMenuWrapper;
+exports["default"] = _default;

web/node_modules/antd/lib/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/lib/table/hooks/useFilter/index.js

@@ -0,0 +1,215 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFilterData = getFilterData;
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useColumns = require("rc-table/lib/hooks/useColumns");
+
+var _util = require("../../util");
+
+var _FilterDropdown = _interopRequireDefault(require("./FilterDropdown"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+function collectFilterStates(columns, init, pos) {
+  var filterStates = [];
+  (columns || []).forEach(function (column, index) {
+    var columnPos = (0, _util.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: (0, _util.getColumnKey)(column, columnPos),
+          filteredKeys: column.filteredValue,
+          forceFiltered: column.filtered
+        });
+      } else {
+        // Uncontrolled
+        filterStates.push({
+          column: column,
+          key: (0, _util.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 = (0, _util.getColumnPos)(index, pos);
+    var _column$filterMultipl = column.filterMultiple,
+        filterMultiple = _column$filterMultipl === void 0 ? true : _column$filterMultipl;
+
+    if (column.filters || 'filterDropdown' in column) {
+      var columnKey = (0, _util.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["default"], {
+            prefixCls: "".concat(prefixCls, "-filter"),
+            dropdownPrefixCls: dropdownPrefixCls,
+            column: column,
+            columnKey: columnKey,
+            filterState: filterState,
+            filterMultiple: filterMultiple,
+            triggerFilter: triggerFilter,
+            locale: locale,
+            getPopupContainer: getPopupContainer
+          }, (0, _util.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;
+}
+
+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 || (0, _useColumns.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];
+}
+
+var _default = useFilter;
+exports["default"] = _default;

web/node_modules/antd/lib/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/lib/table/hooks/useLazyKVMap.js

@@ -0,0 +1,49 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useLazyKVMap;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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/lib/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/lib/table/hooks/usePagination.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPaginationParam = getPaginationParam;
+exports["default"] = usePagination;
+exports.DEFAULT_PAGE_SIZE = void 0;
+
+var _react = require("react");
+
+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 = void 0 && (void 0).__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;
+};
+
+var DEFAULT_PAGE_SIZE = 10;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+
+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;
+}
+
+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 = (0, _react.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/lib/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/lib/table/hooks/useSelection.js

@@ -0,0 +1,446 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useSelection;
+exports.SELECTION_INVERT = exports.SELECTION_ALL = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _DownOutlined = _interopRequireDefault(require("@ant-design/icons/DownOutlined"));
+
+var _checkbox = _interopRequireDefault(require("../../checkbox"));
+
+var _dropdown = _interopRequireDefault(require("../../dropdown"));
+
+var _menu = _interopRequireDefault(require("../../menu"));
+
+var _radio = _interopRequireDefault(require("../../radio"));
+
+var _warning = _interopRequireDefault(require("../../_util/warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+var EMPTY_LIST = []; // TODO: warning if use ajax!!!
+
+var SELECTION_ALL = 'SELECT_ALL';
+exports.SELECTION_ALL = SELECTION_ALL;
+var SELECTION_INVERT = 'SELECT_INVERT';
+exports.SELECTION_INVERT = SELECTION_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;
+}
+
+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) {
+              (0, _warning["default"])(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)) {
+        (0, _warning["default"])(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["default"], {
+          getPopupContainer: getPopupContainer
+        }, mergedSelections.map(function (selection, index) {
+          var key = selection.key,
+              text = selection.text,
+              onSelectionClick = selection.onSelect;
+          return /*#__PURE__*/React.createElement(_menu["default"].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["default"], {
+          overlay: menu,
+          getPopupContainer: getPopupContainer
+        }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(_DownOutlined["default"], 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["default"], {
+        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["default"], _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["default"], _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/lib/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/lib/table/hooks/useSorter.js

@@ -0,0 +1,389 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSortData = getSortData;
+exports["default"] = useFilterSorter;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _useColumns = require("rc-table/lib/hooks/useColumns");
+
+var _CaretDownOutlined = _interopRequireDefault(require("@ant-design/icons/CaretDownOutlined"));
+
+var _CaretUpOutlined = _interopRequireDefault(require("@ant-design/icons/CaretUpOutlined"));
+
+var _tooltip = _interopRequireDefault(require("../../tooltip"));
+
+var _util = require("../util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }
+
+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: (0, _util.getColumnKey)(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  }
+
+  (columns || []).forEach(function (column, index) {
+    var columnPos = (0, _util.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: (0, _util.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 = (0, _util.getColumnPos)(index, pos);
+    var newColumn = column;
+
+    if (newColumn.sorter) {
+      var sortDirections = newColumn.sortDirections || defaultSortDirections;
+      var showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      var columnKey = (0, _util.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["default"], {
+        className: (0, _classnames["default"])("".concat(prefixCls, "-column-sorter-up"), {
+          active: sorterOrder === ASCEND
+        })
+      });
+      var downNode = sortDirections.includes(DESCEND) && /*#__PURE__*/React.createElement(_CaretDownOutlined["default"], {
+        className: (0, _classnames["default"])("".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: (0, _classnames["default"])(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, (0, _util.renderColumnTitle)(column.title, renderProps)), /*#__PURE__*/React.createElement("span", {
+            className: (0, _classnames["default"])("".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["default"], {
+            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 = (0, _classnames["default"])(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;
+}
+
+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;
+  });
+}
+
+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 || (0, _useColumns.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/lib/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/lib/table/hooks/useSyncState.js

@@ -0,0 +1,42 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useSyncState;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 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/lib/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/lib/table/hooks/useTitleColumns.js

@@ -0,0 +1,39 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useTitleColumns;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _util = require("../util");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 fillTitle(columns, columnTitleProps) {
+  return columns.map(function (column) {
+    var cloneColumn = _extends({}, column);
+
+    cloneColumn.title = (0, _util.renderColumnTitle)(column.title, columnTitleProps);
+
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+
+    return cloneColumn;
+  });
+}
+
+function useTitleColumns(columnTitleProps) {
+  var filledColumns = React.useCallback(function (columns) {
+    return fillTitle(columns, columnTitleProps);
+  }, [columnTitleProps]);
+  return [filledColumns];
+}

web/node_modules/antd/lib/table/index.d.ts

@@ -0,0 +1,5 @@
+import Table, { TableProps, TablePaginationConfig } from './Table';
+export { ColumnProps } from './Column';
+export { ColumnsType, ColumnType, ColumnGroupType } from './interface';
+export { TableProps, TablePaginationConfig };
+export default Table;

web/node_modules/antd/lib/table/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _Table = _interopRequireDefault(require("./Table"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _default = _Table["default"];
+exports["default"] = _default;

web/node_modules/antd/lib/table/interface.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="react" />
+import { GetRowKey, ColumnType as RcColumnType, RenderedCell as RcRenderedCell, ExpandableConfig } from 'rc-table/lib/interface';
+import { CheckboxProps } from '../checkbox';
+import { PaginationConfig } from '../pagination';
+export { GetRowKey, ExpandableConfig };
+export declare type Key = React.Key;
+export declare type RowSelectionType = 'checkbox' | 'radio';
+export declare type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+export declare type ExpandType = null | 'row' | 'nest';
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: React.ReactNode;
+    filterReset?: React.ReactNode;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    selectAll?: React.ReactNode;
+    selectInvert?: React.ReactNode;
+    selectionAll?: React.ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export declare type SortOrder = 'descend' | 'ascend' | null;
+export declare type CompareFn<T> = (a: T, b: T, sortOrder?: SortOrder) => number;
+export interface ColumnFilterItem {
+    text: React.ReactNode;
+    value: string | number | boolean;
+    children?: ColumnFilterItem[];
+}
+export interface ColumnTitleProps<RecordType> {
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortOrder?: SortOrder;
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: {
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }[];
+    filters?: Record<string, string[]>;
+}
+export declare type ColumnTitle<RecordType> = React.ReactNode | ((props: ColumnTitleProps<RecordType>) => React.ReactNode);
+export interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: React.Key[]) => void;
+    selectedKeys: React.Key[];
+    confirm: () => void;
+    clearFilters?: () => void;
+    filters?: ColumnFilterItem[];
+    visible: boolean;
+}
+export interface ColumnType<RecordType> extends RcColumnType<RecordType> {
+    title?: ColumnTitle<RecordType>;
+    sorter?: boolean | CompareFn<RecordType> | {
+        compare: CompareFn<RecordType>;
+        /** Config multiple sorter order priority */
+        multiple: number;
+    };
+    sortOrder?: SortOrder;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean;
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    filterDropdown?: React.ReactNode | ((props: FilterDropdownProps) => React.ReactNode);
+    filterMultiple?: boolean;
+    filteredValue?: Key[] | null;
+    defaultFilteredValue?: Key[] | null;
+    filterIcon?: React.ReactNode | ((filtered: boolean) => React.ReactNode);
+    onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
+    filterDropdownVisible?: boolean;
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+export interface ColumnGroupType<RecordType> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+    children: ColumnsType<RecordType>;
+}
+export declare type ColumnsType<RecordType = unknown> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export interface SelectionItem {
+    key: string;
+    text: React.ReactNode;
+    onSelect?: SelectionItemSelectFn;
+}
+export declare type SelectionSelectFn<T> = (record: T, selected: boolean, selectedRows: Object[], nativeEvent: Event) => void;
+export interface TableRowSelection<T> {
+    type?: RowSelectionType;
+    selectedRowKeys?: Key[];
+    onChange?: (selectedRowKeys: Key[], selectedRows: T[]) => void;
+    getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
+    onSelect?: SelectionSelectFn<T>;
+    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is meaningless and should use `onChange` instead */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is meaningless and should use `onChange` instead */
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    selections?: SelectionItem[] | boolean;
+    hideDefaultSelections?: boolean;
+    fixed?: boolean;
+    columnWidth?: string | number;
+    columnTitle?: string | React.ReactNode;
+    renderCell?: (value: boolean, record: T, index: number, originNode: React.ReactNode) => React.ReactNode | RcRenderedCell<T>;
+}
+export declare type TransformColumns<RecordType> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+export interface TableCurrentDataSource<RecordType> {
+    currentDataSource: RecordType[];
+}
+export interface SorterResult<RecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: Key | Key[];
+    columnKey?: Key;
+}
+export declare type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+export interface TablePaginationConfig extends PaginationConfig {
+}

web/node_modules/antd/lib/table/interface.js

@@ -0,0 +1 @@
+"use strict";

web/node_modules/antd/lib/table/style/bordered.less

@@ -0,0 +1,83 @@
+@import './index';
+@import './size';
+
+@table-border: @border-width-base @border-style-base @border-color-split;
+
+.@{table-prefix-cls}.@{table-prefix-cls}-bordered {
+  // ============================ Title =============================
+  .@{table-prefix-cls}-title {
+    border: @table-border;
+    border-bottom: 0;
+  }
+
+  // ============================= Cell =============================
+  thead > tr > th,
+  tbody > tr > td,
+  tfoot > tr > th,
+  tfoot > tr > td {
+    border-right: @table-border;
+  }
+
+  // Fixed right should provides additional border
+  .@{table-prefix-cls}-cell-fix-right-first::after {
+    border-right: @table-border;
+  }
+
+  // ============================ Header ============================
+  table > {
+    thead {
+      > tr:not(:last-child) > th {
+        border-bottom: @border-width-base @border-style-base @border-color-split;
+      }
+    }
+  }
+
+  // =========================== Content ============================
+  .@{table-prefix-cls}-container {
+    border: @table-border;
+    border-right: 0;
+    border-bottom: 0;
+  }
+
+  // ========================== Expandable ==========================
+  .@{table-prefix-cls}-expanded-row-fixed {
+    margin: -@table-padding-vertical (-@table-padding-horizontal - @border-width-base);
+
+    &::after {
+      position: absolute;
+      top: 0;
+      right: @border-width-base;
+      bottom: 0;
+      border-right: @table-border;
+      content: '';
+    }
+  }
+
+  &.@{table-prefix-cls}-scroll-horizontal {
+    tr.@{table-prefix-cls}-expanded-row,
+    tr.@{table-prefix-cls}-placeholder {
+      > td {
+        border-right: 0;
+      }
+    }
+  }
+
+  // Size related
+  &.@{table-prefix-cls}-middle {
+    .@{table-prefix-cls}-expanded-row-fixed {
+      margin: -@table-padding-vertical-md (-@table-padding-horizontal-md - @border-width-base);
+    }
+  }
+
+  &.@{table-prefix-cls}-small {
+    .@{table-prefix-cls}-expanded-row-fixed {
+      margin: -@table-padding-vertical-sm (-@table-padding-horizontal-sm - @border-width-base);
+    }
+  }
+
+  // ============================ Footer ============================
+  .@{table-prefix-cls}-footer {
+    border: @table-border;
+    border-top: 0;
+  }
+}

web/node_modules/antd/lib/table/style/css.js

@@ -0,0 +1,21 @@
+"use strict";
+
+require("../../style/index.css");
+
+require("./index.css");
+
+require("../../button/style/css");
+
+require("../../empty/style/css");
+
+require("../../radio/style/css");
+
+require("../../checkbox/style/css");
+
+require("../../dropdown/style/css");
+
+require("../../spin/style/css");
+
+require("../../pagination/style/css");
+
+require("../../tooltip/style/css");

web/node_modules/antd/lib/table/style/index.css

@@ -0,0 +1,724 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */
+.ant-table.ant-table-middle .ant-table-title,
+.ant-table.ant-table-middle .ant-table-footer,
+.ant-table.ant-table-middle .ant-table-thead > tr > th,
+.ant-table.ant-table-middle .ant-table-tbody > tr > td,
+.ant-table.ant-table-middle tfoot > tr > th,
+.ant-table.ant-table-middle tfoot > tr > td {
+  padding: 12px 8px;
+}
+.ant-table.ant-table-middle .ant-table-thead th.ant-table-column-has-sorters {
+  padding: 0;
+}
+.ant-table.ant-table-middle .ant-table-thead .ant-table-filter-column {
+  margin: -12px -8px;
+}
+.ant-table.ant-table-middle .ant-table-thead .ant-table-filter-column-title {
+  padding: 12px 2.3em 12px 8px;
+}
+.ant-table.ant-table-middle .ant-table-thead .ant-table-column-sorters {
+  padding: 12px 8px;
+}
+.ant-table.ant-table-middle .ant-table-expanded-row-fixed {
+  margin: -12px -8px;
+}
+.ant-table.ant-table-small .ant-table-title,
+.ant-table.ant-table-small .ant-table-footer,
+.ant-table.ant-table-small .ant-table-thead > tr > th,
+.ant-table.ant-table-small .ant-table-tbody > tr > td,
+.ant-table.ant-table-small tfoot > tr > th,
+.ant-table.ant-table-small tfoot > tr > td {
+  padding: 8px 8px;
+}
+.ant-table.ant-table-small .ant-table-thead th.ant-table-column-has-sorters {
+  padding: 0;
+}
+.ant-table.ant-table-small .ant-table-thead .ant-table-filter-column {
+  margin: -8px -8px;
+}
+.ant-table.ant-table-small .ant-table-thead .ant-table-filter-column-title {
+  padding: 8px 2.3em 8px 8px;
+}
+.ant-table.ant-table-small .ant-table-thead .ant-table-column-sorters {
+  padding: 8px 8px;
+}
+.ant-table.ant-table-small .ant-table-expanded-row-fixed {
+  margin: -8px -8px;
+}
+.ant-table-small .ant-table-thead > tr > th {
+  background-color: #fafafa;
+}
+.ant-table.ant-table-bordered .ant-table-title {
+  border: 1px solid #f0f0f0;
+  border-bottom: 0;
+}
+.ant-table.ant-table-bordered thead > tr > th,
+.ant-table.ant-table-bordered tbody > tr > td,
+.ant-table.ant-table-bordered tfoot > tr > th,
+.ant-table.ant-table-bordered tfoot > tr > td {
+  border-right: 1px solid #f0f0f0;
+}
+.ant-table.ant-table-bordered .ant-table-cell-fix-right-first::after {
+  border-right: 1px solid #f0f0f0;
+}
+.ant-table.ant-table-bordered table thead > tr:not(:last-child) > th {
+  border-bottom: 1px solid #f0f0f0;
+}
+.ant-table.ant-table-bordered .ant-table-container {
+  border: 1px solid #f0f0f0;
+  border-right: 0;
+  border-bottom: 0;
+}
+.ant-table.ant-table-bordered .ant-table-expanded-row-fixed {
+  margin: -16px -17px;
+}
+.ant-table.ant-table-bordered .ant-table-expanded-row-fixed::after {
+  position: absolute;
+  top: 0;
+  right: 1px;
+  bottom: 0;
+  border-right: 1px solid #f0f0f0;
+  content: '';
+}
+.ant-table.ant-table-bordered.ant-table-scroll-horizontal tr.ant-table-expanded-row > td,
+.ant-table.ant-table-bordered.ant-table-scroll-horizontal tr.ant-table-placeholder > td {
+  border-right: 0;
+}
+.ant-table.ant-table-bordered.ant-table-middle .ant-table-expanded-row-fixed {
+  margin: -12px -9px;
+}
+.ant-table.ant-table-bordered.ant-table-small .ant-table-expanded-row-fixed {
+  margin: -8px -9px;
+}
+.ant-table.ant-table-bordered .ant-table-footer {
+  border: 1px solid #f0f0f0;
+  border-top: 0;
+}
+.ant-table-wrapper::before {
+  display: table;
+  content: '';
+}
+.ant-table-wrapper::after {
+  display: table;
+  clear: both;
+  content: '';
+}
+.ant-table {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+  z-index: 0;
+  clear: both;
+  background: #fff;
+  border-radius: 2px;
+}
+.ant-table table {
+  width: 100%;
+  text-align: left;
+  border-radius: 2px 2px 0 0;
+  border-collapse: separate;
+  border-spacing: 0;
+}
+.ant-table-thead > tr > th,
+.ant-table-tbody > tr > td,
+.ant-table tfoot > tr > th,
+.ant-table tfoot > tr > td {
+  position: relative;
+  padding: 16px 16px;
+  overflow-wrap: break-word;
+}
+.ant-table-cell-ellipsis {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  word-break: keep-all;
+}
+.ant-table-cell-ellipsis.ant-table-cell-fix-left-last,
+.ant-table-cell-ellipsis.ant-table-cell-fix-right-first {
+  overflow: visible;
+}
+.ant-table-cell-ellipsis.ant-table-cell-fix-left-last .ant-table-cell-content,
+.ant-table-cell-ellipsis.ant-table-cell-fix-right-first .ant-table-cell-content {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.ant-table-title {
+  padding: 16px 16px;
+}
+.ant-table-footer {
+  padding: 16px 16px;
+  color: rgba(0, 0, 0, 0.85);
+  background: #fafafa;
+}
+.ant-table-thead > tr > th {
+  color: rgba(0, 0, 0, 0.85);
+  font-weight: 500;
+  text-align: left;
+  background: #fafafa;
+  border-bottom: 1px solid #f0f0f0;
+  -webkit-transition: background 0.3s ease;
+  transition: background 0.3s ease;
+}
+.ant-table-thead > tr > th[colspan]:not([colspan='1']) {
+  text-align: center;
+}
+.ant-table-thead > tr:not(:last-child) > th[colspan] {
+  border-bottom: 0;
+}
+.ant-table-tbody > tr > td {
+  border-bottom: 1px solid #f0f0f0;
+  -webkit-transition: background 0.3s;
+  transition: background 0.3s;
+}
+.ant-table-tbody > tr.ant-table-row:hover > td {
+  background: #fafafa;
+}
+.ant-table-tbody > tr.ant-table-row-selected > td {
+  background: #e6f7ff;
+}
+.ant-table-tbody > tr.ant-table-row-selected:hover > td {
+  background: #e6f7ff;
+}
+.ant-table-tbody > tr .ant-table-wrapper:only-child .ant-table {
+  margin: -16px -16px -16px 33px;
+}
+.ant-table-tbody > tr .ant-table-wrapper:only-child .ant-table td {
+  background: transparent;
+}
+.ant-table-tbody > tr .ant-table-wrapper:only-child .ant-table-tbody > tr:last-child > td {
+  border-bottom: 0;
+}
+.ant-table-tbody > tr .ant-table-wrapper:only-child .ant-table-tbody > tr:last-child > td:first-child,
+.ant-table-tbody > tr .ant-table-wrapper:only-child .ant-table-tbody > tr:last-child > td:last-child {
+  border-radius: 0;
+}
+.ant-table tfoot > tr > th,
+.ant-table tfoot > tr > td {
+  border-bottom: 1px solid #f0f0f0;
+}
+.ant-table-pagination.ant-pagination {
+  margin: 16px 0;
+}
+.ant-table-pagination-left {
+  float: left;
+}
+.ant-table-pagination-center {
+  text-align: center;
+}
+.ant-table-pagination-right {
+  float: right;
+}
+.ant-table-thead th.ant-table-column-has-sorters {
+  padding: 0;
+  cursor: pointer;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-table-thead th.ant-table-column-has-sorters:hover {
+  background: #f2f2f2;
+}
+.ant-table-thead th.ant-table-column-has-sorters:hover .ant-table-filter-trigger-container {
+  background: #f7f7f7;
+}
+.ant-table-thead th.ant-table-column-sort {
+  background: #f5f5f5;
+}
+td.ant-table-column-sort {
+  background: #fafafa;
+}
+.ant-table-column-sorters-with-tooltip {
+  display: inline-block;
+  width: 100%;
+}
+.ant-table-column-sorters {
+  display: -webkit-inline-box;
+  display: -ms-inline-flexbox;
+  display: inline-flex;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  padding: 16px 16px;
+}
+.ant-table-column-sorter {
+  margin-top: 0.15em;
+  margin-bottom: -0.15em;
+  margin-left: 8px;
+  color: #bfbfbf;
+}
+.ant-table-column-sorter-full {
+  margin-top: -0.2em;
+  margin-bottom: 0;
+}
+.ant-table-column-sorter-inner {
+  display: -webkit-inline-box;
+  display: -ms-inline-flexbox;
+  display: inline-flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.ant-table-column-sorter-up,
+.ant-table-column-sorter-down {
+  display: inline-block;
+  font-size: 11px;
+}
+.ant-table-column-sorter-up.active,
+.ant-table-column-sorter-down.active {
+  color: #1890ff;
+}
+.ant-table-column-sorter-up + .ant-table-column-sorter-down {
+  margin-top: -0.3em;
+}
+.ant-table-filter-column {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  margin: -16px -16px;
+}
+.ant-table-filter-column-title {
+  -webkit-box-flex: 1;
+      -ms-flex: auto;
+          flex: auto;
+  padding: 16px 2.3em 16px 16px;
+}
+.ant-table-thead tr th.ant-table-column-has-sorters .ant-table-filter-column {
+  margin: 0;
+}
+.ant-table-thead tr th.ant-table-column-has-sorters .ant-table-filter-column-title {
+  padding: 0 2.3em 0 0;
+}
+.ant-table-filter-trigger-container {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 0;
+      -ms-flex: none;
+          flex: none;
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+  cursor: pointer;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+}
+.ant-table-filter-trigger-container-open,
+.ant-table-filter-trigger-container:hover,
+.ant-table-thead th.ant-table-column-has-sorters:hover .ant-table-filter-trigger-container:hover {
+  background: #e5e5e5;
+}
+.ant-table-filter-trigger {
+  display: block;
+  width: 2.3em;
+  color: #bfbfbf;
+  font-size: 12px;
+  -webkit-transition: color 0.3s;
+  transition: color 0.3s;
+}
+.ant-table-filter-trigger .anticon {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  -webkit-transform: translate(-50%, -50%);
+          transform: translate(-50%, -50%);
+}
+.ant-table-filter-trigger-container-open .ant-table-filter-trigger,
+.ant-table-filter-trigger:hover {
+  color: rgba(0, 0, 0, 0.45);
+}
+.ant-table-filter-trigger.active {
+  color: #1890ff;
+}
+.ant-table-filter-dropdown {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  min-width: 120px;
+  background-color: #fff;
+  border-radius: 2px;
+  -webkit-box-shadow: 0 3px 6px -4px rgba(0, 0, 0, 0.12), 0 6px 16px 0 rgba(0, 0, 0, 0.08), 0 9px 28px 8px rgba(0, 0, 0, 0.05);
+          box-shadow: 0 3px 6px -4px rgba(0, 0, 0, 0.12), 0 6px 16px 0 rgba(0, 0, 0, 0.08), 0 9px 28px 8px rgba(0, 0, 0, 0.05);
+}
+.ant-table-filter-dropdown .ant-dropdown-menu {
+  max-height: calc(100vh - 130px);
+  overflow-x: hidden;
+  border: 0;
+  -webkit-box-shadow: none;
+          box-shadow: none;
+}
+.ant-table-filter-dropdown-submenu > ul {
+  max-height: calc(100vh - 130px);
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+.ant-table-filter-dropdown .ant-checkbox-wrapper + span,
+.ant-table-filter-dropdown-submenu .ant-checkbox-wrapper + span {
+  padding-left: 8px;
+}
+.ant-table-filter-dropdown-btns {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-pack: justify;
+      -ms-flex-pack: justify;
+          justify-content: space-between;
+  padding: 7px 8px 7px 3px;
+  overflow: hidden;
+  background-color: inherit;
+  border-top: 1px solid #f0f0f0;
+}
+.ant-table colgroup > col.ant-table-selection-col {
+  width: 60px;
+}
+table tr th.ant-table-selection-column,
+table tr td.ant-table-selection-column {
+  text-align: center;
+}
+table tr th.ant-table-selection-column .ant-radio-wrapper,
+table tr td.ant-table-selection-column .ant-radio-wrapper {
+  margin-right: 0;
+}
+.ant-table-selection {
+  position: relative;
+}
+.ant-table-selection-extra {
+  position: absolute;
+  top: 0;
+  right: -10px;
+  cursor: pointer;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-table-selection-extra .anticon {
+  display: inline-block;
+  font-size: 10px;
+  color: #bfbfbf;
+}
+.ant-table-selection-extra .anticon:hover {
+  color: #a6a6a6;
+}
+.ant-table-expand-icon-col {
+  width: 48px;
+}
+.ant-table-row-expand-icon-cell {
+  text-align: center;
+}
+.ant-table-row-indent {
+  float: left;
+  height: 1px;
+}
+.ant-table-row-expand-icon {
+  color: #1890ff;
+  text-decoration: none;
+  cursor: pointer;
+  -webkit-transition: color 0.3s;
+  transition: color 0.3s;
+  position: relative;
+  display: -webkit-inline-box;
+  display: -ms-inline-flexbox;
+  display: inline-flex;
+  float: left;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  width: 17px;
+  height: 17px;
+  padding: 0;
+  color: inherit;
+  line-height: 12px;
+  vertical-align: -2px;
+  background: #fff;
+  border: 1px solid #f0f0f0;
+  border-radius: 2px;
+  outline: none;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+}
+.ant-table-row-expand-icon:focus,
+.ant-table-row-expand-icon:hover {
+  color: #40a9ff;
+}
+.ant-table-row-expand-icon:active {
+  color: #096dd9;
+}
+.ant-table-row-expand-icon:focus,
+.ant-table-row-expand-icon:hover,
+.ant-table-row-expand-icon:active {
+  border-color: currentColor;
+}
+.ant-table-row-expand-icon::before,
+.ant-table-row-expand-icon::after {
+  position: absolute;
+  background: currentColor;
+  -webkit-transition: -webkit-transform 0.3s ease-out;
+  transition: -webkit-transform 0.3s ease-out;
+  transition: transform 0.3s ease-out;
+  transition: transform 0.3s ease-out, -webkit-transform 0.3s ease-out;
+  content: '';
+}
+.ant-table-row-expand-icon::before {
+  top: 7px;
+  right: 3px;
+  left: 3px;
+  height: 1px;
+}
+.ant-table-row-expand-icon::after {
+  top: 3px;
+  bottom: 3px;
+  left: 7px;
+  width: 1px;
+  -webkit-transform: rotate(90deg);
+          transform: rotate(90deg);
+}
+.ant-table-row-expand-icon-collapsed::before {
+  -webkit-transform: rotate(-180deg);
+          transform: rotate(-180deg);
+}
+.ant-table-row-expand-icon-collapsed::after {
+  -webkit-transform: rotate(0deg);
+          transform: rotate(0deg);
+}
+.ant-table-row-expand-icon-spaced {
+  background: transparent;
+  border: 0;
+}
+.ant-table-row-expand-icon-spaced::before,
+.ant-table-row-expand-icon-spaced::after {
+  display: none;
+  content: none;
+}
+.ant-table-row-indent + .ant-table-row-expand-icon {
+  margin-top: 2.5005px;
+  margin-right: 8px;
+}
+tr.ant-table-expanded-row > td,
+tr.ant-table-expanded-row:hover > td {
+  background: #fbfbfb;
+}
+.ant-table .ant-table-expanded-row-fixed {
+  position: relative;
+  margin: -16px -16px;
+  padding: 16px 16px;
+}
+.ant-table-tbody > tr.ant-table-placeholder {
+  text-align: center;
+}
+.ant-table-tbody > tr.ant-table-placeholder:hover > td {
+  background: #fff;
+}
+.ant-table-cell-fix-left,
+.ant-table-cell-fix-right {
+  position: -webkit-sticky !important;
+  position: sticky !important;
+  z-index: 2;
+  background: #fff;
+}
+.ant-table-cell-fix-left-first::after,
+.ant-table-cell-fix-left-last::after {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: -1px;
+  width: 30px;
+  -webkit-transform: translateX(100%);
+          transform: translateX(100%);
+  -webkit-transition: -webkit-box-shadow 0.3s;
+  transition: -webkit-box-shadow 0.3s;
+  transition: box-shadow 0.3s;
+  transition: box-shadow 0.3s, -webkit-box-shadow 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.ant-table-cell-fix-right-first::after,
+.ant-table-cell-fix-right-last::after {
+  position: absolute;
+  top: 0;
+  bottom: -1px;
+  left: 0;
+  width: 30px;
+  -webkit-transform: translateX(-100%);
+          transform: translateX(-100%);
+  -webkit-transition: -webkit-box-shadow 0.3s;
+  transition: -webkit-box-shadow 0.3s;
+  transition: box-shadow 0.3s;
+  transition: box-shadow 0.3s, -webkit-box-shadow 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.ant-table .ant-table-container::before,
+.ant-table .ant-table-container::after {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  z-index: 1;
+  width: 30px;
+  -webkit-transition: -webkit-box-shadow 0.3s;
+  transition: -webkit-box-shadow 0.3s;
+  transition: box-shadow 0.3s;
+  transition: box-shadow 0.3s, -webkit-box-shadow 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.ant-table .ant-table-container::before {
+  left: 0;
+}
+.ant-table .ant-table-container::after {
+  right: 0;
+}
+.ant-table-ping-left:not(.ant-table-has-fix-left) .ant-table-container {
+  position: relative;
+}
+.ant-table-ping-left:not(.ant-table-has-fix-left) .ant-table-container::before {
+  -webkit-box-shadow: inset 10px 0 8px -8px rgba(0, 0, 0, 0.15);
+          box-shadow: inset 10px 0 8px -8px rgba(0, 0, 0, 0.15);
+}
+.ant-table-ping-left .ant-table-cell-fix-left-first::after,
+.ant-table-ping-left .ant-table-cell-fix-left-last::after {
+  -webkit-box-shadow: inset 10px 0 8px -8px rgba(0, 0, 0, 0.15);
+          box-shadow: inset 10px 0 8px -8px rgba(0, 0, 0, 0.15);
+}
+.ant-table-ping-right:not(.ant-table-has-fix-right) .ant-table-container {
+  position: relative;
+}
+.ant-table-ping-right:not(.ant-table-has-fix-right) .ant-table-container::after {
+  -webkit-box-shadow: inset -10px 0 8px -8px rgba(0, 0, 0, 0.15);
+          box-shadow: inset -10px 0 8px -8px rgba(0, 0, 0, 0.15);
+}
+.ant-table-ping-right .ant-table-cell-fix-right-first::after,
+.ant-table-ping-right .ant-table-cell-fix-right-last::after {
+  -webkit-box-shadow: inset -10px 0 8px -8px rgba(0, 0, 0, 0.15);
+          box-shadow: inset -10px 0 8px -8px rgba(0, 0, 0, 0.15);
+}
+@media all and (-ms-high-contrast: none) {
+  .ant-table-ping-left .ant-table-cell-fix-left-last::after {
+    -webkit-box-shadow: none !important;
+            box-shadow: none !important;
+  }
+  .ant-table-ping-right .ant-table-cell-fix-right-first::after {
+    -webkit-box-shadow: none !important;
+            box-shadow: none !important;
+  }
+}
+.ant-table {
+  /* title + table */
+  /* table */
+  /* table + footer */
+}
+.ant-table-title {
+  border-radius: 2px 2px 0 0;
+}
+.ant-table-title + .ant-table-container {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+.ant-table-title + .ant-table-container table > thead > tr:first-child th:first-child {
+  border-radius: 0;
+}
+.ant-table-title + .ant-table-container table > thead > tr:first-child th:last-child {
+  border-radius: 0;
+}
+.ant-table-container {
+  border-top-left-radius: 2px;
+  border-top-right-radius: 2px;
+}
+.ant-table-container table > thead > tr:first-child th:first-child {
+  border-top-left-radius: 2px;
+}
+.ant-table-container table > thead > tr:first-child th:last-child {
+  border-top-right-radius: 2px;
+}
+.ant-table-footer {
+  border-radius: 0 0 2px 2px;
+}
+.ant-table-wrapper-rtl {
+  direction: rtl;
+}
+.ant-table-rtl {
+  direction: rtl;
+}
+.ant-table-wrapper-rtl .ant-table table {
+  text-align: right;
+}
+.ant-table-wrapper-rtl .ant-table-thead > tr > th[colspan]:not([colspan='1']) {
+  text-align: center;
+}
+.ant-table-wrapper-rtl .ant-table-thead > tr > th {
+  text-align: right;
+}
+.ant-table-tbody > tr .ant-table.ant-table-rtl {
+  margin: -16px 33px -16px -16px;
+}
+.ant-table-wrapper-rtl .ant-table-pagination.ant-pagination {
+  float: left;
+}
+.ant-table-wrapper-rtl .ant-table-column-sorter {
+  margin-right: 8px;
+  margin-left: 0;
+}
+.ant-table-wrapper-rtl .ant-table-filter-column-title {
+  padding: 16px 16px 16px 2.3em;
+}
+.ant-table-wrapper-rtl .ant-table-filter-trigger-container {
+  right: auto;
+  left: 0;
+}
+.ant-dropdown-rtl .ant-table-filter-dropdown .ant-checkbox-wrapper + span,
+.ant-dropdown-rtl .ant-table-filter-dropdown-submenu .ant-checkbox-wrapper + span {
+  padding-right: 8px;
+  padding-left: 0;
+}
+.ant-table-wrapper-rtl .ant-table-selection {
+  text-align: center;
+}
+.ant-table-wrapper-rtl .ant-table-selection-extra {
+  right: auto;
+  left: 0;
+  -webkit-transform: translate(-100%, -50%);
+          transform: translate(-100%, -50%);
+}
+.ant-table-wrapper-rtl .ant-table-row-indent {
+  float: right;
+}
+.ant-table-wrapper-rtl .ant-table-row-expand-icon {
+  float: right;
+}
+.ant-table-wrapper-rtl .ant-table-row-indent + .ant-table-row-expand-icon {
+  margin-right: 0;
+  margin-left: 8px;
+}

web/node_modules/antd/lib/table/style/index.d.ts

@@ -0,0 +1,10 @@
+import '../../style/index.less';
+import './index.less';
+import '../../button/style';
+import '../../empty/style';
+import '../../radio/style';
+import '../../checkbox/style';
+import '../../dropdown/style';
+import '../../spin/style';
+import '../../pagination/style';
+import '../../tooltip/style';

web/node_modules/antd/lib/table/style/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+require("../../style/index.less");
+
+require("./index.less");
+
+require("../../button/style");
+
+require("../../empty/style");
+
+require("../../radio/style");
+
+require("../../checkbox/style");
+
+require("../../dropdown/style");
+
+require("../../spin/style");
+
+require("../../pagination/style");
+
+require("../../tooltip/style");

web/node_modules/antd/lib/table/style/index.less

@@ -0,0 +1,609 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import './size';
+@import './bordered';
+
+@table-prefix-cls: ~'@{ant-prefix}-table';
+@dropdown-prefix-cls: ~'@{ant-prefix}-dropdown';
+@table-header-icon-color: #bfbfbf;
+@table-header-icon-color-hover: darken(@table-header-icon-color, 10%);
+@table-header-sort-active-filter-bg: lighten(@table-header-sort-active-bg, 2%);
+
+@table-selection-column-width: 60px;
+
+.@{table-prefix-cls}-wrapper {
+  .clearfix;
+}
+
+.@{table-prefix-cls} {
+  .reset-component;
+  position: relative;
+  z-index: 0;
+  clear: both;
+  background: @table-bg;
+  border-radius: @border-radius-base;
+
+  // https://github.com/ant-design/ant-design/issues/17611
+  table {
+    width: 100%;
+    text-align: left;
+    border-radius: @table-border-radius-base @table-border-radius-base 0 0;
+    border-collapse: separate;
+    border-spacing: 0;
+  }
+
+  // ============================= Cell =============================
+  &-thead > tr > th,
+  &-tbody > tr > td,
+  tfoot > tr > th,
+  tfoot > tr > td {
+    position: relative;
+    padding: @table-padding-vertical @table-padding-horizontal;
+    overflow-wrap: break-word;
+  }
+
+  &-cell-ellipsis {
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    word-break: keep-all;
+
+    // Fixed first or last should special process
+    &.@{table-prefix-cls}-cell-fix-left-last,
+    &.@{table-prefix-cls}-cell-fix-right-first {
+      overflow: visible;
+
+      .@{table-prefix-cls}-cell-content {
+        display: block;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+    }
+  }
+
+  // ============================ Title =============================
+  &-title {
+    padding: @table-padding-vertical @table-padding-horizontal;
+  }
+
+  // ============================ Footer ============================
+  &-footer {
+    padding: @table-padding-vertical @table-padding-horizontal;
+    color: @table-footer-color;
+    background: @table-footer-bg;
+  }
+
+  // ============================ Header ============================
+  &-thead {
+    > tr {
+      > th {
+        color: @table-header-color;
+        font-weight: 500;
+        text-align: left;
+        background: @table-header-bg;
+        border-bottom: @border-width-base @border-style-base @border-color-split;
+        transition: background 0.3s ease;
+
+        &[colspan]:not([colspan='1']) {
+          text-align: center;
+        }
+      }
+    }
+
+    > tr:not(:last-child) > th {
+      &[colspan] {
+        border-bottom: 0;
+      }
+    }
+  }
+
+  // ============================= Body =============================
+  &-tbody {
+    > tr {
+      > td {
+        border-bottom: @border-width-base @border-style-base @border-color-split;
+        transition: background 0.3s;
+      }
+
+      &.@{table-prefix-cls}-row:hover {
+        > td {
+          background: @table-row-hover-bg;
+        }
+      }
+
+      &.@{table-prefix-cls}-row-selected {
+        > td {
+          background: @table-selected-row-bg;
+        }
+
+        &:hover {
+          > td {
+            background: @table-selected-row-hover-bg;
+          }
+        }
+      }
+
+      // ========================= Nest Table ===========================
+      .@{table-prefix-cls}-wrapper:only-child {
+        .@{table-prefix-cls} {
+          margin: -@table-padding-vertical -@table-padding-horizontal -@table-padding-vertical (@table-padding-horizontal +
+                ceil(@font-size-sm * 1.4));
+
+          td {
+            background: transparent;
+          }
+
+          &-tbody > tr:last-child > td {
+            border-bottom: 0;
+
+            &:first-child,
+            &:last-child {
+              border-radius: 0;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // =========================== Summary ============================
+  tfoot {
+    > tr {
+      > th,
+      > td {
+        border-bottom: @border-width-base @border-style-base @border-color-split;
+      }
+    }
+  }
+
+  // ========================== Pagination ==========================
+  &-pagination.@{ant-prefix}-pagination {
+    margin: 16px 0;
+  }
+
+  &-pagination {
+    &-left {
+      float: left;
+    }
+
+    &-center {
+      text-align: center;
+    }
+
+    &-right {
+      float: right;
+    }
+  }
+
+  // ================================================================
+  // =                           Function                           =
+  // ================================================================
+
+  // ============================ Sorter ============================
+  &-thead th.@{table-prefix-cls}-column-has-sorters {
+    padding: 0;
+    cursor: pointer;
+    transition: all 0.3s;
+
+    &:hover {
+      background: @table-header-sort-active-bg;
+
+      .@{table-prefix-cls}-filter-trigger-container {
+        background: @table-header-sort-active-filter-bg;
+      }
+    }
+  }
+
+  &-thead th.@{table-prefix-cls}-column-sort {
+    background: @table-header-sort-bg;
+  }
+  td&-column-sort {
+    background: @table-body-sort-bg;
+  }
+
+  &-column-sorters-with-tooltip {
+    display: inline-block;
+    width: 100%;
+  }
+
+  &-column-sorters {
+    display: inline-flex;
+    align-items: center;
+    padding: @table-padding-vertical @table-padding-horizontal;
+  }
+
+  &-column-sorter {
+    margin-top: 0.15em;
+    margin-bottom: -0.15em;
+    margin-left: @padding-xs;
+    color: @table-header-icon-color;
+
+    &-full {
+      margin-top: -0.2em;
+      margin-bottom: 0;
+    }
+
+    &-inner {
+      display: inline-flex;
+      flex-direction: column;
+      align-items: center;
+    }
+
+    &-up,
+    &-down {
+      .iconfont-size-under-12px(11px);
+
+      &.active {
+        color: @primary-color;
+      }
+    }
+
+    &-up + &-down {
+      margin-top: -0.3em;
+    }
+  }
+
+  // ============================ Filter ============================
+  &-filter-column {
+    display: flex;
+    align-items: center;
+    margin: -@table-padding-vertical -@table-padding-horizontal;
+  }
+
+  &-filter-column-title {
+    flex: auto;
+    padding: @table-padding-vertical 2.3em @table-padding-vertical @table-padding-horizontal;
+  }
+
+  // Remove padding when sorter also provided
+  &-thead tr th.@{table-prefix-cls}-column-has-sorters {
+    .@{table-prefix-cls}-filter-column {
+      margin: 0;
+    }
+
+    .@{table-prefix-cls}-filter-column-title {
+      padding: 0 2.3em 0 0;
+    }
+  }
+
+  &-filter-trigger-container {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    flex: none;
+    align-items: stretch;
+    align-self: stretch;
+    cursor: pointer;
+    transition: background-color 0.3s;
+
+    &-open,
+    &:hover,
+    .@{table-prefix-cls}-thead th.@{table-prefix-cls}-column-has-sorters:hover &:hover {
+      background: @table-header-filter-active-bg;
+    }
+  }
+
+  &-filter-trigger {
+    display: block;
+    width: 2.3em;
+    color: @table-header-icon-color;
+    font-size: @font-size-sm;
+    transition: color 0.3s;
+
+    .@{iconfont-css-prefix} {
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+    }
+
+    .@{table-prefix-cls}-filter-trigger-container-open &,
+    &:hover {
+      color: @text-color-secondary;
+    }
+
+    &.active {
+      color: @primary-color;
+    }
+  }
+
+  // Dropdown
+  &-filter-dropdown {
+    .reset-component;
+
+    // Reset menu
+    .@{dropdown-prefix-cls}-menu {
+      // https://github.com/ant-design/ant-design/issues/4916
+      // https://github.com/ant-design/ant-design/issues/19542
+      max-height: calc(100vh - 130px);
+      overflow-x: hidden;
+      border: 0;
+      box-shadow: none;
+    }
+
+    min-width: 120px;
+    background-color: @table-filter-dropdown-bg;
+
+    border-radius: @border-radius-base;
+    box-shadow: @box-shadow-base;
+
+    &-submenu > ul {
+      max-height: calc(100vh - 130px);
+      overflow-x: hidden;
+      overflow-y: auto;
+    }
+
+    // Checkbox
+    &,
+    &-submenu {
+      .@{ant-prefix}-checkbox-wrapper + span {
+        padding-left: 8px;
+      }
+    }
+
+    // Operation
+    &-btns {
+      display: flex;
+      justify-content: space-between;
+      padding: 7px 8px 7px 3px;
+      overflow: hidden;
+      background-color: @table-filter-btns-bg;
+      border-top: @border-width-base @border-style-base @border-color-split;
+    }
+  }
+
+  // ========================== Selections ==========================
+  colgroup {
+    > col.@{table-prefix-cls}-selection-col {
+      width: @table-selection-column-width;
+    }
+  }
+
+  table tr th&-selection-column,
+  table tr td&-selection-column {
+    text-align: center;
+
+    .@{ant-prefix}-radio-wrapper {
+      margin-right: 0;
+    }
+  }
+
+  &-selection {
+    position: relative;
+
+    &-extra {
+      position: absolute;
+      top: 0;
+      right: -10px;
+      cursor: pointer;
+      transition: all 0.3s;
+
+      .@{iconfont-css-prefix} {
+        .iconfont-size-under-12px(10px);
+        color: @table-header-icon-color;
+
+        &:hover {
+          color: @table-header-icon-color-hover;
+        }
+      }
+    }
+  }
+
+  // ========================== Expandable ==========================
+  &-expand-icon-col {
+    width: 48px;
+  }
+
+  &-row-expand-icon-cell {
+    text-align: center;
+  }
+
+  &-row-indent {
+    float: left;
+    height: 1px;
+  }
+
+  &-row-expand-icon {
+    .operation-unit();
+    position: relative;
+    display: inline-flex;
+    float: left;
+    box-sizing: border-box;
+
+    width: ceil(@font-size-sm * 1.4);
+    height: ceil(@font-size-sm * 1.4);
+    padding: 0;
+    color: inherit;
+    line-height: @font-size-sm;
+    vertical-align: floor((@font-size-base - ceil(@font-size-sm * 1.4)) / 2);
+    background: @table-expand-icon-bg;
+    border: @border-width-base @border-style-base @border-color-split;
+    border-radius: @border-radius-base;
+    outline: none;
+    transition: all 0.3s;
+    user-select: none;
+
+    &:focus,
+    &:hover,
+    &:active {
+      border-color: currentColor;
+    }
+
+    &::before,
+    &::after {
+      position: absolute;
+      background: currentColor;
+      transition: transform 0.3s ease-out;
+      content: '';
+    }
+
+    &::before {
+      top: 7px;
+      right: 3px;
+      left: 3px;
+      height: @border-width-base;
+    }
+
+    &::after {
+      top: 3px;
+      bottom: 3px;
+      left: 7px;
+      width: @border-width-base;
+      transform: rotate(90deg);
+    }
+
+    // Motion effect
+    &-collapsed::before {
+      transform: rotate(-180deg);
+    }
+    &-collapsed::after {
+      transform: rotate(0deg);
+    }
+
+    &-spaced {
+      &::before,
+      &::after {
+        display: none;
+        content: none;
+      }
+      background: transparent;
+      border: 0;
+    }
+
+    .@{table-prefix-cls}-row-indent + & {
+      margin-top: (@font-size-base * @line-height-base - ceil(@font-size-sm * 1.4)) / 2;
+      margin-right: @padding-xs;
+    }
+  }
+
+  tr&-expanded-row {
+    &,
+    &:hover {
+      > td {
+        background: @table-expanded-row-bg;
+      }
+    }
+  }
+
+  // With fixed
+  .@{table-prefix-cls}-expanded-row-fixed {
+    position: relative;
+    margin: -@table-padding-vertical -@table-padding-horizontal;
+    padding: @table-padding-vertical @table-padding-horizontal;
+  }
+
+  // ========================= Placeholder ==========================
+  &-tbody > tr&-placeholder {
+    text-align: center;
+    &:hover {
+      > td {
+        background: @component-background;
+      }
+    }
+  }
+
+  // ============================ Fixed =============================
+  &-cell-fix-left,
+  &-cell-fix-right {
+    position: -webkit-sticky !important;
+    position: sticky !important;
+    z-index: 2;
+    background: @table-bg;
+  }
+
+  &-cell-fix-left-first::after,
+  &-cell-fix-left-last::after {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: -1px;
+    width: 30px;
+    transform: translateX(100%);
+    transition: box-shadow 0.3s;
+    content: '';
+    pointer-events: none;
+  }
+  &-cell-fix-right-first::after,
+  &-cell-fix-right-last::after {
+    position: absolute;
+    top: 0;
+    bottom: -1px;
+    left: 0;
+    width: 30px;
+    transform: translateX(-100%);
+    transition: box-shadow 0.3s;
+    content: '';
+    pointer-events: none;
+  }
+
+  .@{table-prefix-cls}-container {
+    &::before,
+    &::after {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      z-index: 1;
+      width: 30px;
+      transition: box-shadow 0.3s;
+      content: '';
+      pointer-events: none;
+    }
+
+    &::before {
+      left: 0;
+    }
+    &::after {
+      right: 0;
+    }
+  }
+
+  &-ping-left {
+    &:not(.@{table-prefix-cls}-has-fix-left) .@{table-prefix-cls}-container {
+      position: relative;
+
+      &::before {
+        box-shadow: inset 10px 0 8px -8px darken(@shadow-color, 5%);
+      }
+    }
+
+    .@{table-prefix-cls}-cell-fix-left-first::after,
+    .@{table-prefix-cls}-cell-fix-left-last::after {
+      box-shadow: inset 10px 0 8px -8px darken(@shadow-color, 5%);
+    }
+  }
+
+  &-ping-right {
+    &:not(.@{table-prefix-cls}-has-fix-right) .@{table-prefix-cls}-container {
+      position: relative;
+
+      &::after {
+        box-shadow: inset -10px 0 8px -8px darken(@shadow-color, 5%);
+      }
+    }
+
+    .@{table-prefix-cls}-cell-fix-right-first::after,
+    .@{table-prefix-cls}-cell-fix-right-last::after {
+      box-shadow: inset -10px 0 8px -8px darken(@shadow-color, 5%);
+    }
+  }
+}
+
+@media all and (-ms-high-contrast: none) {
+  .@{table-prefix-cls} {
+    &-ping-left {
+      .@{table-prefix-cls}-cell-fix-left-last::after {
+        box-shadow: none !important;
+      }
+    }
+    &-ping-right {
+      .@{table-prefix-cls}-cell-fix-right-first::after {
+        box-shadow: none !important;
+      }
+    }
+  }
+}
+
+@import './radius';
+@import './rtl';

web/node_modules/antd/lib/table/style/radius.less

@@ -0,0 +1,45 @@
+// ================================================================
+// =                         Border Radio                         =
+// ================================================================
+.@{table-prefix-cls} {
+  /* title + table */
+  &-title {
+    border-radius: @table-border-radius-base @table-border-radius-base 0 0;
+  }
+
+  &-title + &-container {
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+
+    table > thead > tr:first-child {
+      th:first-child {
+        border-radius: 0;
+      }
+
+      th:last-child {
+        border-radius: 0;
+      }
+    }
+  }
+
+  /* table */
+  &-container {
+    border-top-left-radius: @table-border-radius-base;
+    border-top-right-radius: @table-border-radius-base;
+
+    table > thead > tr:first-child {
+      th:first-child {
+        border-top-left-radius: @table-border-radius-base;
+      }
+
+      th:last-child {
+        border-top-right-radius: @table-border-radius-base;
+      }
+    }
+  }
+
+  /* table + footer */
+  &-footer {
+    border-radius: 0 0 @table-border-radius-base @table-border-radius-base;
+  }
+}

web/node_modules/antd/lib/table/style/rtl.less

@@ -0,0 +1,134 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@table-prefix-cls: ~'@{ant-prefix}-table';
+@table-wrapepr-rtl-cls: ~'@{table-prefix-cls}-wrapper-rtl';
+
+.@{table-prefix-cls}-wrapper {
+  &-rtl {
+    direction: rtl;
+  }
+}
+
+.@{table-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+  }
+
+  table {
+    .@{table-wrapepr-rtl-cls} & {
+      text-align: right;
+    }
+  }
+
+  // ============================ Header ============================
+  &-thead {
+    > tr {
+      > th {
+        &[colspan]:not([colspan='1']) {
+          .@{table-wrapepr-rtl-cls} & {
+            text-align: center;
+          }
+        }
+
+        .@{table-wrapepr-rtl-cls} & {
+          text-align: right;
+        }
+      }
+    }
+  }
+
+  // ============================= Body =============================
+  &-tbody {
+    > tr {
+      // ========================= Nest Table ===========================
+      .@{table-prefix-cls} {
+        &.@{table-prefix-cls}-rtl {
+          margin: -@table-padding-vertical (@table-padding-horizontal + ceil(@font-size-sm * 1.4)) -@table-padding-vertical -@table-padding-horizontal;
+        }
+      }
+    }
+  }
+
+  // ========================== Pagination ==========================
+  &-pagination.@{ant-prefix}-pagination {
+    .@{table-wrapepr-rtl-cls} & {
+      float: left;
+    }
+  }
+
+  // ================================================================
+  // =                           Function                           =
+  // ================================================================
+
+  // ============================ Sorter ============================
+  &-column-sorter {
+    .@{table-wrapepr-rtl-cls} & {
+      margin-right: @padding-xs;
+      margin-left: 0;
+    }
+  }
+
+  // ============================ Filter ============================
+  &-filter-column-title {
+    .@{table-wrapepr-rtl-cls} & {
+      padding: @table-padding-vertical @table-padding-horizontal @table-padding-vertical 2.3em;
+    }
+  }
+
+  &-filter-trigger-container {
+    .@{table-wrapepr-rtl-cls} & {
+      right: auto;
+      left: 0;
+    }
+  }
+
+  // Dropdown
+  &-filter-dropdown {
+    // Checkbox
+    &,
+    &-submenu {
+      .@{ant-prefix}-checkbox-wrapper + span {
+        .@{ant-prefix}-dropdown-rtl & {
+          padding-right: 8px;
+          padding-left: 0;
+        }
+      }
+    }
+  }
+
+  // ========================== Selections ==========================
+  &-selection {
+    .@{table-wrapepr-rtl-cls} & {
+      text-align: center;
+    }
+
+    &-extra {
+      .@{table-wrapepr-rtl-cls} & {
+        right: auto;
+        left: 0;
+        transform: translate(-100%, -50%);
+      }
+    }
+  }
+
+  // ========================== Expandable ==========================
+  &-row-indent {
+    .@{table-wrapepr-rtl-cls} & {
+      float: right;
+    }
+  }
+
+  &-row-expand-icon {
+    .@{table-wrapepr-rtl-cls} & {
+      float: right;
+    }
+
+    .@{table-prefix-cls}-row-indent + & {
+      .@{table-wrapepr-rtl-cls} & {
+        margin-right: 0;
+        margin-left: @padding-xs;
+      }
+    }
+  }
+}

web/node_modules/antd/lib/table/style/size.less

@@ -0,0 +1,52 @@
+@import './index';
+
+.table-size(@size, @padding-vertical, @padding-horizontal) {
+  .@{table-prefix-cls}.@{table-prefix-cls}-@{size} {
+    .@{table-prefix-cls}-title,
+    .@{table-prefix-cls}-footer,
+    .@{table-prefix-cls}-thead > tr > th,
+    .@{table-prefix-cls}-tbody > tr > td,
+    tfoot > tr > th,
+    tfoot > tr > td {
+      padding: @padding-vertical @padding-horizontal;
+    }
+
+    .@{table-prefix-cls}-thead {
+      th.@{table-prefix-cls}-column-has-sorters {
+        padding: 0;
+      }
+
+      .@{table-prefix-cls}-filter-column {
+        margin: -@padding-vertical -@padding-horizontal;
+      }
+
+      .@{table-prefix-cls}-filter-column-title {
+        padding: @padding-vertical 2.3em @padding-vertical @padding-horizontal;
+      }
+
+      .@{table-prefix-cls}-column-sorters {
+        padding: @padding-vertical @padding-horizontal;
+      }
+    }
+
+    .@{table-prefix-cls}-expanded-row-fixed {
+      margin: -@padding-vertical -@padding-horizontal;
+    }
+  }
+}
+
+// ================================================================
+// =                            Middle                            =
+// ================================================================
+.table-size(~'middle', @table-padding-vertical-md, @table-padding-horizontal-md);
+
+// ================================================================
+// =                            Small                             =
+// ================================================================
+.table-size(~'small', @table-padding-vertical-sm, @table-padding-horizontal-sm);
+
+.@{table-prefix-cls}-small {
+  .@{table-prefix-cls}-thead > tr > th {
+    background-color: @table-header-bg-sm;
+  }
+}

web/node_modules/antd/lib/table/util.d.ts

@@ -0,0 +1,4 @@
+import { ColumnType, ColumnTitle, ColumnTitleProps, Key } from './interface';
+export declare function getColumnKey<RecordType>(column: ColumnType<RecordType>, defaultKey: string): Key;
+export declare function getColumnPos(index: number, pos?: string): string;
+export declare function renderColumnTitle<RecordType>(title: ColumnTitle<RecordType>, props: ColumnTitleProps<RecordType>): any;

web/node_modules/antd/lib/table/util.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getColumnKey = getColumnKey;
+exports.getColumnPos = getColumnPos;
+exports.renderColumnTitle = renderColumnTitle;
+
+function getColumnKey(column, defaultKey) {
+  if ('key' in column && column.key !== undefined && column.key !== null) {
+    return column.key;
+  }
+
+  if (column.dataIndex) {
+    return Array.isArray(column.dataIndex) ? column.dataIndex.join('.') : column.dataIndex;
+  }
+
+  return defaultKey;
+}
+
+function getColumnPos(index, pos) {
+  return pos ? "".concat(pos, "-").concat(index) : "".concat(index);
+}
+
+function renderColumnTitle(title, props) {
+  if (typeof title === 'function') {
+    return title(props);
+  }
+
+  return title;
+}