@fle-ui/next 2.0.0-alpha.3 → 2.0.0-alpha.6

package/lib/table/hooks/useSorter.js

@@ -0,0 +1,395 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useFilterSorter;
+exports.getSortData = getSortData;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _extends3 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _CaretDownOutlined = _interopRequireDefault(require("@ant-design/icons/CaretDownOutlined"));
+
+var _CaretUpOutlined = _interopRequireDefault(require("@ant-design/icons/CaretUpOutlined"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _tooltip = _interopRequireDefault(require("../../tooltip"));
+
+var _util = require("../util");
+
+var ASCEND = 'ascend';
+var DESCEND = 'descend';
+
+function getMultiplePriority(column) {
+  if ((0, _typeof2["default"])(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 && (0, _typeof2["default"])(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((0, _toConsumableArray2["default"])(sortStates), (0, _toConsumableArray2["default"])(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, sorterStates, 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 = sorterStates.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
+        }),
+        role: "presentation"
+      });
+      var downNode = sortDirections.includes(DESCEND) && /*#__PURE__*/React.createElement(_CaretDownOutlined["default"], {
+        className: (0, _classnames["default"])("".concat(prefixCls, "-column-sorter-down"), {
+          active: sorterOrder === DESCEND
+        }),
+        role: "presentation"
+      });
+
+      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;
+      }
+
+      var tooltipProps = (0, _typeof2["default"])(showSorterTooltip) === 'object' ? showSorterTooltip : {
+        title: sortTip
+      };
+      newColumn = (0, _extends3["default"])((0, _extends3["default"])({}, newColumn), {
+        className: (0, _classnames["default"])(newColumn.className, (0, _defineProperty2["default"])({}, "".concat(prefixCls, "-column-sort"), sorterOrder)),
+        title: function title(renderProps) {
+          var renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: "".concat(prefixCls, "-column-sorters")
+          }, /*#__PURE__*/React.createElement("span", {
+            className: "".concat(prefixCls, "-column-title")
+          }, (0, _util.renderColumnTitle)(column.title, renderProps)), /*#__PURE__*/React.createElement("span", {
+            className: (0, _classnames["default"])("".concat(prefixCls, "-column-sorter"), (0, _defineProperty2["default"])({}, "".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"], (0, _extends3["default"])({}, tooltipProps), renderSortTitle) : renderSortTitle;
+        },
+        onHeaderCell: function onHeaderCell(col) {
+          var cell = column.onHeaderCell && column.onHeaderCell(col) || {};
+          var originOnClick = cell.onClick;
+          var originOKeyDown = cell.onKeyDown;
+
+          cell.onClick = function (event) {
+            triggerSorter({
+              column: column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+            originOnClick === null || originOnClick === void 0 ? void 0 : originOnClick(event);
+          };
+
+          cell.onKeyDown = function (event) {
+            if (event.keyCode === _KeyCode["default"].ENTER) {
+              triggerSorter({
+                column: column,
+                key: columnKey,
+                sortOrder: nextSortOrder,
+                multiplePriority: getMultiplePriority(column)
+              });
+              originOKeyDown === null || originOKeyDown === void 0 ? void 0 : originOKeyDown(event);
+            }
+          };
+
+          var renderTitle = (0, _util.safeColumnTitle)(column.title, {});
+          var displayTitle = renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle.toString(); // Inform the screen-reader so it can tell the visually impaired user which column is sorted
+
+          if (sorterOrder) {
+            cell['aria-sort'] = sorterOrder === 'ascend' ? 'ascending' : 'descending';
+          } else {
+            cell['aria-label'] = "".concat(displayTitle ? "this column's title is ".concat(displayTitle, ",") : '', "this column is sortable");
+          }
+
+          cell.className = (0, _classnames["default"])(cell.className, "".concat(prefixCls, "-column-has-sorters"));
+          cell.tabIndex = 0;
+
+          if (column.ellipsis) {
+            cell.title = (renderTitle !== null && renderTitle !== void 0 ? renderTitle : '').toString();
+          }
+
+          return cell;
+        }
+      });
+    }
+
+    if ('children' in newColumn) {
+      newColumn = (0, _extends3["default"])((0, _extends3["default"])({}, newColumn), {
+        children: injectSorter(prefixCls, newColumn.children, sorterStates, 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 (0, _extends3["default"])((0, _extends3["default"])({}, stateToInfo(sorterStates[sorterStates.length - 1])), {
+      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 (0, _extends3["default"])((0, _extends3["default"])({}, record), (0, _defineProperty2["default"])({}, childrenColumnName, getSortData(subRecords, sortStates, childrenColumnName)));
+    }
+
+    return record;
+  });
+}
+
+function useFilterSorter(_ref5) {
+  var prefixCls = _ref5.prefixCls,
+      mergedColumns = _ref5.mergedColumns,
+      onSorterChange = _ref5.onSorterChange,
+      sortDirections = _ref5.sortDirections,
+      tableLocale = _ref5.tableLocale,
+      showSorterTooltip = _ref5.showSorterTooltip;
+
+  var _React$useState = React.useState(collectSortStates(mergedColumns, true)),
+      _React$useState2 = (0, _slicedToArray2["default"])(_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((0, _extends3["default"])((0, _extends3["default"])({}, 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((0, _toConsumableArray2["default"])(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];
+}

package/lib/table/hooks/useTitleColumns.d.ts

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

package/lib/table/hooks/useTitleColumns.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useTitleColumns;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _util = require("../util");
+
+function fillTitle(columns, columnTitleProps) {
+  return columns.map(function (column) {
+    var cloneColumn = (0, _extends2["default"])({}, 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];
+}

package/lib/table/index.d.ts

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

package/lib/table/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _Table = _interopRequireDefault(require("./Table"));
+
+var _default = _Table["default"];
+exports["default"] = _default;

package/lib/table/interface.d.ts

@@ -0,0 +1,164 @@
+import type { ColumnType as RcColumnType, FixedType, RenderedCell as RcRenderedCell } from 'rc-table/lib/interface';
+import { ExpandableConfig, GetRowKey } from 'rc-table/lib/interface';
+import type * as React from 'react';
+import type { CheckboxProps } from '../checkbox';
+import type { PaginationProps } from '../pagination';
+import type { TooltipProps } from '../tooltip';
+import type { Breakpoint } from '../_util/responsiveObserve';
+import type { INTERNAL_SELECTION_ITEM } from './hooks/useSelection';
+export { GetRowKey, ExpandableConfig };
+export type Key = React.Key;
+export type RowSelectionType = 'checkbox' | 'radio';
+export type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+export type ExpandType = null | 'row' | 'nest';
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: React.ReactNode;
+    filterReset?: React.ReactNode;
+    filterEmptyText?: React.ReactNode;
+    filterCheckall?: React.ReactNode;
+    filterSearchPlaceholder?: string;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    selectAll?: React.ReactNode;
+    selectNone?: React.ReactNode;
+    selectInvert?: React.ReactNode;
+    selectionAll?: React.ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export type SortOrder = 'descend' | 'ascend' | null;
+declare const TableActions: ["paginate", "sort", "filter"];
+export type TableAction = typeof TableActions[number];
+export 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, FilterValue>;
+}
+export type ColumnTitle<RecordType> = React.ReactNode | ((props: ColumnTitleProps<RecordType>) => React.ReactNode);
+export type FilterValue = (Key | boolean)[];
+export type FilterKey = Key[] | null;
+export type FilterSearchType<RecordType = Record<string, any>> = boolean | ((input: string, record: RecordType) => boolean);
+export interface FilterConfirmProps {
+    closeDropdown: boolean;
+}
+export interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: React.Key[]) => void;
+    selectedKeys: React.Key[];
+    /**
+     * Confirm filter value, if you want to close dropdown before commit, you can call with
+     * {closeDropdown: true}
+     */
+    confirm: (param?: FilterConfirmProps) => void;
+    clearFilters?: () => void;
+    filters?: ColumnFilterItem[];
+    /** Only close filterDropdown */
+    close: () => void;
+    visible: boolean;
+}
+export interface ColumnType<RecordType> extends Omit<RcColumnType<RecordType>, 'title'> {
+    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 | TooltipProps;
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    filterDropdown?: React.ReactNode | ((props: FilterDropdownProps) => React.ReactNode);
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: React.ReactNode | ((filtered: boolean) => React.ReactNode);
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem>;
+    onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
+    /**
+     * @deprecated `filterDropdownVisible` is deprecated which will be removed in next major version.
+     *   Please use `filterDropdownOpen` instead.
+     */
+    filterDropdownVisible?: boolean;
+    filterDropdownOpen?: boolean;
+    /**
+     * @deprecated `onFilterDropdownVisibleChange` is deprecated which will be removed in next major
+     *   version. Please use `onFilterDropdownOpenChange` instead.
+     */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+    onFilterDropdownOpenChange?: (open: boolean) => void;
+    filterResetToDefaultFilteredValue?: boolean;
+    responsive?: Breakpoint[];
+}
+export interface ColumnGroupType<RecordType> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+    children: ColumnsType<RecordType>;
+}
+export type ColumnsType<RecordType = unknown> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export interface SelectionItem {
+    key: string;
+    text: React.ReactNode;
+    onSelect?: SelectionItemSelectFn;
+}
+export type SelectionSelectFn<T> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
+export type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+export interface TableRowSelection<T> {
+    /** Keep the selection keys in list even the key not exist in `dataSource` anymore */
+    preserveSelectedRowKeys?: boolean;
+    type?: RowSelectionType;
+    selectedRowKeys?: Key[];
+    defaultSelectedRowKeys?: Key[];
+    onChange?: (selectedRowKeys: Key[], selectedRows: T[], info: {
+        type: RowSelectMethod;
+    }) => void;
+    getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
+    onSelect?: SelectionSelectFn<T>;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectNone?: () => void;
+    selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+    hideSelectAll?: boolean;
+    fixed?: FixedType;
+    columnWidth?: string | number;
+    columnTitle?: string | React.ReactNode;
+    checkStrictly?: boolean;
+    renderCell?: (value: boolean, record: T, index: number, originNode: React.ReactNode) => React.ReactNode | RcRenderedCell<T>;
+}
+export type TransformColumns<RecordType> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+export interface TableCurrentDataSource<RecordType> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+export interface SorterResult<RecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: Key | readonly Key[];
+    columnKey?: Key;
+}
+export type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+export interface TablePaginationConfig extends PaginationProps {
+    position?: TablePaginationPosition[];
+}

package/lib/table/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var _type = require("../_util/type");
+
+var TableActions = (0, _type.tuple)('paginate', 'sort', 'filter');