@hsu-react/ui 0.0.1

package/lib/components/Table/_hooks/useSetTableHeight.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { TableProps } from "..";
+interface Params {
+    pagination?: TableProps["pagination"];
+    scroll?: TableProps["scroll"];
+    scrollAutoHeight?: boolean;
+    ref?: React.RefObject<HTMLDivElement>;
+    dataSource?: TableProps["dataSource"];
+    cls?: string;
+    fillPanel?: boolean;
+    columns?: TableProps["columns"];
+    bordered?: boolean;
+    virtual?: boolean;
+}
+declare const useSetTableHeight: (params: Params) => void;
+export default useSetTableHeight;

package/lib/components/Table/_hooks/useSetTableHeight.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _ahooks = require("ahooks");
+const useSetTableHeight = params => {
+  const {
+    pagination,
+    scroll,
+    scrollAutoHeight,
+    ref,
+    dataSource,
+    cls,
+    fillPanel,
+    columns,
+    bordered,
+    virtual
+  } = params;
+  const [ready, setReady] = (0, _react.useState)(false);
+  (0, _react.useEffect)(() => {
+    if (scroll && ref && ref.current && ready && columns?.length && !virtual) {
+      const header = document.querySelector(`.${cls} .ant-table-header`);
+      const body = document.querySelector(`.${cls} .ant-table-tbody`);
+      const _pagination = document.querySelector(`.${cls} .ant-pagination`);
+      const simplePagination = document.querySelector(`.${cls} [class^='PaginationSimple']`);
+      const summary = document.querySelector(`.${cls} .ant-table-summary`);
+      const table = ref.current;
+      const height = `${header?.offsetHeight + body?.offsetHeight + (summary ? summary?.offsetHeight : 0) + (pagination ? _pagination ? _pagination?.offsetHeight + 10 : simplePagination ? simplePagination?.offsetHeight + 10 : 0 : 0) + (bordered ? 1 : 0) + (body?.offsetWidth > table.offsetWidth ? 5 : 0)}px`;
+      if (scrollAutoHeight && !fillPanel) {
+        table.style.height = height;
+        if (typeof scroll === "object" && scroll.y !== false || scroll === true) {
+          table.style.maxHeight = "100%";
+        }
+      }
+    }
+  }, [dataSource, fillPanel, cls, pagination, ref, scroll, scrollAutoHeight, ready, columns, bordered, virtual]);
+  (0, _ahooks.useMutationObserver)(() => {
+    setReady(true);
+  }, ref, {
+    childList: true,
+    subtree: true
+  });
+};
+var _default = exports.default = useSetTableHeight;

package/lib/components/Table/_hooks/useTableColumns.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+import { ColumnsType, TableProps } from "..";
+import { AnyObject } from "antd/es/_util/type";
+import { TableRowSelection } from "antd/es/table/interface";
+import { PaginationProps } from "../_components/Pagination";
+interface UseTableColumnsParams<T extends AnyObject> {
+    columns?: ColumnsType<T>;
+    scroll?: boolean | {
+        y: boolean;
+    };
+    autoWidth?: boolean;
+    dataSource?: TableProps<T>["dataSource"];
+    enhanceColumns: (columns?: ColumnsType<T>) => ColumnsType<T> | undefined;
+    serialNumberColumn?: boolean;
+    pagination?: false | PaginationProps;
+    _pageNum: number;
+    _pageSize: number;
+    order?: {
+        k: string;
+        t: "asc" | "desc";
+    };
+    mergeRowDataSource?: readonly T[] | undefined;
+    onChange?: TableProps<T>["onChange"];
+    onOrderChange?: (order?: {
+        k: string;
+        t: "asc" | "desc";
+    }) => void;
+    sorter?: boolean;
+    ref?: React.RefObject<HTMLDivElement>;
+    cls?: string;
+    bordered?: boolean;
+    rowSelection?: TableRowSelection<T>;
+    expandable?: TableProps<T>["expandable"];
+}
+declare const useTableColumns: <T extends AnyObject>(params: UseTableColumnsParams<T>) => {
+    _columns: ColumnsType<T>;
+    renderedColumns: ColumnsType<T> | undefined;
+    handleTableChange: TableProps<T>["onChange"];
+};
+export default useTableColumns;

package/lib/components/Table/_hooks/useTableColumns.js

@@ -0,0 +1,250 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _lodash = require("lodash");
+var _antd = require("antd");
+var _Icon = _interopRequireDefault(require("../../Icon"));
+var _indexModule = _interopRequireDefault(require("../index.module.less"));
+var _hsuUtils = require("hsu-utils");
+var _classnames = _interopRequireDefault(require("classnames"));
+var _tableUtils = require("../_utils/tableUtils");
+var _usePermissions = _interopRequireDefault(require("../../../hooks/usePermissions"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const useTableColumns = params => {
+  const {
+    columns = [],
+    scroll,
+    autoWidth,
+    dataSource,
+    enhanceColumns,
+    serialNumberColumn = false,
+    pagination,
+    _pageNum,
+    _pageSize,
+    order,
+    mergeRowDataSource,
+    onChange,
+    onOrderChange,
+    sorter,
+    ref,
+    cls,
+    bordered,
+    rowSelection,
+    expandable
+  } = params;
+  const {
+    checkPermission
+  } = (0, _usePermissions.default)();
+  const [tableWidth, setTableWidth] = (0, _react.useState)(null);
+
+  // 监听表格宽度变化
+  (0, _react.useEffect)(() => {
+    if (ref?.current && cls) {
+      const tableElement = document.querySelector(`.${cls} .ant-table`);
+      if (tableElement) {
+        const updateWidth = () => {
+          const width = tableElement.offsetWidth;
+          if (width > 0) {
+            setTableWidth(width);
+          }
+        };
+        updateWidth();
+        const resizeObserver = new ResizeObserver(updateWidth);
+        resizeObserver.observe(tableElement);
+        return () => resizeObserver.disconnect();
+      }
+    }
+  }, [ref, cls]);
+
+  // 处理列的基础设置（权限、宽度、排序等）
+  const _columns = (0, _react.useMemo)(() => {
+    const cloned = (0, _lodash.cloneDeep)(columns);
+    const newColumns = cloned?.map((item, idx) => {
+      return {
+        ...item,
+        width: !item.width ? "100%" : item.width,
+        key: item.key ?? item.dataIndex ?? `col_${idx}`,
+        hidden: !checkPermission(item.hasPermi) || item.hidden,
+        ellipsis: typeof item.ellipsis === "boolean" ? item.ellipsis : true
+      };
+    })?.sort((a, b) => (a?.sort ?? 0) - (b?.sort ?? 0))?.map(item => {
+      if (autoWidth && item.width === "100%" && scroll && (typeof item.title === "string" || typeof item.title === "number")) {
+        let {
+          width: titleWidth
+        } = (0, _hsuUtils.get_string_size)(item.title?.toString(), {
+          size: 14
+        });
+        if (item.help) {
+          titleWidth += 22;
+        }
+        const dataIndexWidth = item.dataIndex ? dataSource?.reduce((acc, cur) => {
+          return Math.max(acc, (0, _hsuUtils.get_string_size)(cur[item.dataIndex]?.toString(), {
+            size: 14
+          }).width);
+        }, 0) ?? 0 : 0;
+        item.width = Math.max(titleWidth, dataIndexWidth) + 32;
+      }
+      return item;
+    })?.map(item => {
+      return {
+        ...item,
+        width: item.hidden ? 0.01 : item.width,
+        className: (0, _classnames.default)(item.className, {
+          [_indexModule.default.hidden]: item.hidden
+        }),
+        hidden: undefined
+      };
+    });
+    return newColumns;
+  }, [autoWidth, columns, dataSource, checkPermission, scroll]);
+
+  // 渲染列标题
+  const renderColumnTitle = (0, _react.useCallback)(column => {
+    const titleContent = column?.titleSort ? column.titleSort : column.renderTitle ? column.renderTitle(column.title || "") : column.title;
+    if (!column.help) {
+      return titleContent;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+      children: [titleContent, /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tooltip, {
+        title: column.help,
+        ..._tableUtils.HELP_TOOLTIP_CONFIG,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Icon.default, {
+          icon: "material-symbols:help",
+          className: _indexModule.default.help,
+          fontSize: 16,
+          color: "#999999"
+        })
+      })]
+    });
+  }, []);
+  const renderColumns = (0, _react.useCallback)(columns => {
+    // 先增强列配置，为 ellipsis 列添加自动 Tooltip
+    let enhancedColumns = enhanceColumns(columns);
+    if (serialNumberColumn && !_columns.find(v => !!v.children)) {
+      enhancedColumns?.unshift({
+        title: "序号",
+        dataIndex: "serialNumber",
+        width: 60,
+        align: "center",
+        render: (_, __, index) => {
+          return pagination ? (_pageNum - 1) * _pageSize + (index + 1) : index + 1;
+        },
+        fixedWidth: true
+      });
+    }
+
+    // 处理 fixedWidth 列的宽度分配（在 enhancedColumns 基础上）
+    if (enhancedColumns && tableWidth && tableWidth > 0) {
+      // 检查是否有 fixedWidth 为 true 的列
+      const hasFixedWidth = enhancedColumns.some(col => col.fixedWidth === true);
+      if (hasFixedWidth) {
+        // 过滤出可见列（排除 hidden 列，即宽度为 0.01 的列）
+        const visibleColumns = enhancedColumns.filter(col => typeof col.width === "number" && col.width > 0.01);
+
+        // 检查所有可见列是否都有宽度（非"100%"）
+        const allHaveWidth = visibleColumns.every(col => col.width && col.width !== "100%" && typeof col.width === "number");
+        if (allHaveWidth && visibleColumns.length > 0) {
+          // 计算所有可见列的宽度总和
+          const totalWidth = visibleColumns.reduce((sum, col) => {
+            const width = typeof col.width === "number" ? col.width : 0;
+            return sum + width;
+          }, 0);
+
+          // 如果总和小于表格宽度，按比例分配给非 fixedWidth 的可见列
+          // 当 bordered 为 true 时，tableWidth 需要减去 2（边框宽度）
+          // 当有 rowSelection 时，tableWidth 需要减去 48（选择列宽度）
+          let adjustedTableWidth = bordered ? tableWidth - 2 : tableWidth;
+          if (rowSelection) {
+            adjustedTableWidth -= 48;
+          }
+          if (expandable) {
+            adjustedTableWidth -= 48;
+          }
+          if (totalWidth < adjustedTableWidth) {
+            const extraWidth = adjustedTableWidth - totalWidth;
+            const nonFixedWidthColumns = visibleColumns.filter(col => col.fixedWidth !== true);
+            const nonFixedWidthTotal = nonFixedWidthColumns.reduce((sum, col) => {
+              const width = typeof col.width === "number" ? col.width : 0;
+              return sum + width;
+            }, 0);
+            if (nonFixedWidthTotal > 0) {
+              // 按比例分配多余宽度
+              enhancedColumns = enhancedColumns?.map(col => {
+                // hidden 列（宽度为 0.01）或 fixedWidth 列保持原宽度
+                const currentWidth = typeof col.width === "number" ? col.width : 0;
+                if (col.fixedWidth === true || currentWidth <= 0.01) {
+                  return col;
+                }
+                const ratio = currentWidth / nonFixedWidthTotal;
+                const additionalWidth = extraWidth * ratio;
+                return {
+                  ...col,
+                  width: +(currentWidth + additionalWidth).toFixed(2)
+                };
+              });
+            }
+          }
+        }
+      }
+    }
+    return enhancedColumns?.map(column => {
+      const orderKey = column.orderKey || column.dataIndex;
+      const isOrderColumn = orderKey && orderKey !== "serialNumber";
+      return {
+        showSorterTooltip: false,
+        sorter: typeof sorter === "boolean" ? sorter : isOrderColumn ? true : false,
+        ...column,
+        orderKey,
+        title: renderColumnTitle(column),
+        children: column?.children ? renderColumns(column.children) : undefined,
+        onCell: (record, index) => {
+          const cell = column?.onCell?.(record, index);
+          let rowSpan = 1;
+          if (column.mergeRow) {
+            rowSpan = (0, _tableUtils.getDepartmentRowSpan)(record, index, mergeRowDataSource, column.dataIndex);
+          }
+          return {
+            rowSpan,
+            ...cell
+          };
+        },
+        sortOrder: order?.k === orderKey ? order?.t === "desc" ? "descend" : "ascend" : undefined
+      };
+    });
+  }, [enhanceColumns, serialNumberColumn, _columns, tableWidth, pagination, _pageNum, _pageSize, bordered, rowSelection, expandable, sorter, renderColumnTitle, order, mergeRowDataSource]);
+
+  // 缓存渲染后的列配置
+  const renderedColumns = (0, _react.useMemo)(() => renderColumns((0, _lodash.cloneDeep)(_columns)), [renderColumns, _columns]);
+
+  // 处理排序变化
+  const handleTableChange = (0, _react.useCallback)((pagination, filters, sorter, extra) => {
+    onChange?.(pagination, filters, sorter, extra);
+    const sorterResult = Array.isArray(sorter) ? sorter[0] : sorter;
+    const {
+      column,
+      order: _order
+    } = sorterResult;
+    const columnOrderKey = column?.orderKey;
+    const k = columnOrderKey ?? order?.k;
+    if (!k || !_order) {
+      onOrderChange?.(undefined);
+    } else {
+      const t = _order === "ascend" ? "asc" : "desc";
+      onOrderChange?.({
+        k,
+        t
+      });
+    }
+  }, [onChange, onOrderChange, order]);
+  return {
+    _columns: _columns,
+    renderedColumns: renderedColumns,
+    handleTableChange
+  };
+};
+var _default = exports.default = useTableColumns;

package/lib/components/Table/_hooks/useTablePagination.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { PaginationProps } from "../_components/Pagination";
+import { TableProps } from "..";
+import { AnyObject } from "antd/es/_util/type";
+interface UseTablePaginationParams<T extends AnyObject> {
+    dataSource?: TableProps<T>["dataSource"];
+    pagination?: false | PaginationProps;
+    staticDataSource?: boolean;
+    current?: number;
+    pageSize?: number;
+    onChangePage?: (page: number, pageSize: number) => void;
+    onShowSizeChange?: (page: number, pageSize: number) => void;
+    onStaticPaginationChange?: (page: number, pageSize: number) => void;
+}
+declare const useTablePagination: <T extends AnyObject>(params: UseTablePaginationParams<T>) => {
+    _pageNum: number;
+    _pageSize: number;
+    _dataSource: readonly T[] | undefined;
+    setPageNum: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setPageSize: import("react").Dispatch<import("react").SetStateAction<number>>;
+    paginatedDataSource: readonly T[] | undefined;
+    mergeRowDataSource: readonly T[] | undefined;
+    handlePageChange: (num: number, size: number) => void;
+    handlePageSizeChange: (page: number, size: number) => void;
+};
+export default useTablePagination;

package/lib/components/Table/_hooks/useTablePagination.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _hsuUtils = require("hsu-utils");
+var _usePaginationSync = _interopRequireDefault(require("./usePaginationSync"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const useTablePagination = params => {
+  const {
+    dataSource,
+    pagination,
+    staticDataSource = false,
+    onChangePage,
+    onShowSizeChange,
+    onStaticPaginationChange
+  } = params;
+
+  // 直接传入原始值，不使用默认值，让 usePaginationSync 自行处理
+  const {
+    _pageNum,
+    _pageSize,
+    setPageNum,
+    setPageSize
+  } = (0, _usePaginationSync.default)({
+    current: params.current,
+    pageSize: params.pageSize
+  });
+  const [_dataSource, setDataSource] = (0, _react.useState)([]);
+  (0, _react.useEffect)(() => {
+    if (!_hsuUtils.Equal.ObjEqual(dataSource, _dataSource)) {
+      setDataSource(dataSource);
+      if (staticDataSource) {
+        setPageNum(1);
+      }
+    }
+  }, [_dataSource, dataSource, staticDataSource, setPageNum]);
+
+  // 计算分页数据源
+  const paginatedDataSource = (0, _react.useMemo)(() => {
+    if (!pagination) return dataSource;
+    if (staticDataSource) {
+      const start = _pageSize * (_pageNum - 1);
+      return _dataSource?.slice(start, start + _pageSize);
+    }
+    return dataSource;
+  }, [pagination, staticDataSource, _dataSource, _pageSize, _pageNum, dataSource]);
+
+  // 计算用于合并行的数据源
+  const mergeRowDataSource = (0, _react.useMemo)(() => {
+    if (!pagination) return dataSource;
+    const start = _pageSize * (_pageNum - 1);
+    return _dataSource?.slice(start, start + _pageSize);
+  }, [pagination, _dataSource, _pageSize, _pageNum, dataSource]);
+
+  // 处理分页变化
+  const handlePageChange = (0, _react.useCallback)((num, size) => {
+    setPageNum(num);
+    setPageSize(size);
+    onChangePage?.(num, size);
+    // 当使用 staticDataSource 时，通过 onStaticPaginationChange 传递变化
+    if (staticDataSource) {
+      onStaticPaginationChange?.(num, size);
+    }
+  }, [onChangePage, onStaticPaginationChange, staticDataSource, setPageNum, setPageSize]);
+
+  // 处理分页大小变化
+  const handlePageSizeChange = (0, _react.useCallback)((page, size) => {
+    setPageNum(page);
+    setPageSize(size);
+    onShowSizeChange?.(page, size);
+    // 当使用 staticDataSource 时，通过 onStaticPaginationChange 传递变化
+    if (staticDataSource) {
+      onStaticPaginationChange?.(page, size);
+    }
+  }, [onShowSizeChange, onStaticPaginationChange, staticDataSource, setPageNum, setPageSize]);
+  return {
+    _pageNum,
+    _pageSize,
+    _dataSource,
+    setPageNum,
+    setPageSize,
+    paginatedDataSource,
+    mergeRowDataSource,
+    handlePageChange,
+    handlePageSizeChange
+  };
+};
+var _default = exports.default = useTablePagination;

package/lib/components/Table/_utils/tableUtils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 获取相同值的连续行数
+ * @param record 当前行数据
+ * @param index 当前行索引
+ * @param dataSource 数据源
+ * @param key 相同值的key
+ * @returns 相同值的连续行数
+ */
+export declare function getDepartmentRowSpan<T extends Record<string, unknown>>(record: T, index: number, dataSource: T[], key: string): number;
+/**
+ * Tooltip 配置常量
+ */
+export declare const HELP_TOOLTIP_CONFIG: {
+    arrow: boolean;
+    placement: "top";
+    color: string;
+    styles: {
+        body: {
+            color: string;
+            padding: string;
+        };
+    };
+};

package/lib/components/Table/_utils/tableUtils.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HELP_TOOLTIP_CONFIG = void 0;
+exports.getDepartmentRowSpan = getDepartmentRowSpan;
+/**
+ * 获取相同值的连续行数
+ * @param record 当前行数据
+ * @param index 当前行索引
+ * @param dataSource 数据源
+ * @param key 相同值的key
+ * @returns 相同值的连续行数
+ */
+function getDepartmentRowSpan(record, index, dataSource, key) {
+  const current = record[key];
+
+  // 如果不是该值的第一行，返回0（不显示）
+  if (index > 0 && dataSource[index - 1][key] === current) {
+    return 0;
+  }
+
+  // 计算相同值的连续行数
+  let count = 1;
+  for (let i = index + 1; i < dataSource.length; i++) {
+    if (dataSource[i][key] === current) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+/**
+ * Tooltip 配置常量
+ */
+const HELP_TOOLTIP_CONFIG = exports.HELP_TOOLTIP_CONFIG = {
+  arrow: false,
+  placement: "top",
+  color: "#f2f4f5",
+  styles: {
+    body: {
+      color: "#131212",
+      padding: "6px 16px"
+    }
+  }
+};

package/lib/components/Table/index.d.ts

@@ -0,0 +1,91 @@
+import { ColumnType as AntColumnType, ColumnGroupType as AntColumnGroupType } from "antd/lib/table";
+import { TableProps as AntdTableProps, TooltipProps } from "antd";
+import Drag, { DragProps } from "./_components/Drag";
+import { PaginationProps } from "./_components/Pagination";
+import React, { ReactNode } from "react";
+import { AnyObject } from "antd/es/_util/type";
+import { ColumnTitleProps } from "antd/lib/table/interface";
+export { Drag as TableDrag };
+export interface EllipsisTooltipConfig extends Omit<TooltipProps, "title" | "children"> {
+    ellipsisPosition?: "start" | "end";
+    defaultWidth?: number;
+}
+export interface ColumnType<RecordType> extends AntColumnType<RecordType> {
+    title?: string;
+    renderTitle?: (title: string) => ReactNode;
+    titleSort?: (props: ColumnTitleProps<RecordType>) => ReactNode;
+    dataIndex?: string;
+    hidden?: boolean;
+    sort?: number;
+    hasPermi?: string[];
+    children?: ColumnType<RecordType>[];
+    mergeRow?: boolean;
+    help?: string;
+    orderKey?: string;
+    fixedWidth?: boolean;
+    ellipsisPosition?: "start" | "end";
+}
+export interface ColumnsGroupType<RecordType> extends Omit<AntColumnGroupType<RecordType>, "children"> {
+    title?: string;
+    renderTitle?: (title: string) => ReactNode;
+    titleSort?: (props: ColumnTitleProps<RecordType>) => ReactNode;
+    dataIndex?: string;
+    hidden?: boolean;
+    sort?: number;
+    hasPermi?: string[];
+    children?: ColumnsGroupType<RecordType>[];
+    mergeRow?: boolean;
+    help?: string;
+    orderKey?: string;
+    fixedWidth?: boolean;
+    ellipsisPosition?: "start" | "end";
+}
+export type ColumnsType<RecordType = AnyObject> = (ColumnType<RecordType> | ColumnsGroupType<RecordType>)[];
+export interface TableProps<RecordType = AnyObject> extends Omit<AntdTableProps<RecordType>, "scroll" | "pagination" | "columns"> {
+    columns?: ColumnsType<RecordType>;
+    scroll?: boolean | {
+        y: boolean;
+    };
+    autoWidth?: boolean;
+    scrollAutoHeight?: boolean;
+    hideScrollbar?: boolean;
+    thPadding?: string;
+    tdPadding?: string;
+    expandedCellPadding?: string;
+    pagination?: false | PaginationProps;
+    onDragEnd?: DragProps["onDragEnd"];
+    tableClassName?: string;
+    fillPanel?: boolean;
+    staticDataSource?: boolean;
+    antdTableClassName?: string;
+    autoScrolling?: boolean;
+    autoScrollingInterval?: number;
+    /** smooth 模式自动滚动速度，单位 px/s，默认 25 */
+    autoScrollingSpeed?: number;
+    autoScrollMode?: "smooth" | "row";
+    /** 自动滚动到末尾后是否循环回到顶部，默认 true */
+    autoScrollLoop?: boolean;
+    /** 循环模式："reset" 回到顶部重新滚动（默认），"seamless" 无缝衔接继续滚动 */
+    autoScrollLoopMode?: "reset" | "seamless";
+    /** 自动滚动偏移量阈值（px），可滚动溢出超过该值后才启动自动滚动，默认 0 */
+    autoScrollingOffset?: number;
+    hideEmpty?: boolean;
+    ellipsisTooltipConfig?: EllipsisTooltipConfig;
+    serialNumberColumn?: boolean;
+    onAutoScrollEndAdd?: () => Promise<boolean>;
+    onScrollEnd?: () => void;
+    order?: {
+        k: string;
+        t: "asc" | "desc";
+    };
+    onOrderChange?: (order?: {
+        k: string;
+        t: "asc" | "desc";
+    }) => void;
+    sorter?: boolean;
+    showTotal?: false | ((total: number, range: [number, number]) => ReactNode);
+    isExpandedCellTable?: boolean;
+}
+type TableFC = (<T extends AnyObject>(props: TableProps<T>) => JSX.Element | null) & React.FC<TableProps<AnyObject>>;
+declare const Table: TableFC;
+export default Table;