@rainbow-oh/yee-c 0.8.12 → 0.8.13

package/dist/cjs/Table/col-group.d.ts

@@ -3,5 +3,5 @@ import { ColumnProps } from './interface';
 interface TableColGroupProps {
     columns: Array<ColumnProps>;
 }
-declare const _default: React.MemoExoticComponent<React.MemoExoticComponent<({ columns }: TableColGroupProps) => React.JSX.Element>>;
-export default _default;
+declare const ColGroup: React.MemoExoticComponent<({ columns }: TableColGroupProps) => React.JSX.Element>;
+export default ColGroup;

package/dist/cjs/Table/col-group.js

@@ -62,4 +62,4 @@ var ColGroup = import_react.default.memo(({ columns }) => {
   }));
 }, areEqual);
 ColGroup.displayName = "ColGroup";
-var col_group_default = import_react.default.memo(ColGroup);
+var col_group_default = ColGroup;

package/dist/cjs/Table/demo/sorter-callback.js

@@ -56,8 +56,9 @@ var sorter_callback_default = () => {
       title: "Score",
       dataIndex: "score",
       key: "score",
-      sorter: true,
-      defaultSortOrder: "descend"
+      sorter: {
+        defaultSortOrder: "descend"
+      }
     },
     {
       title: "Address",

package/dist/cjs/Table/demo/sorter.js

@@ -46,8 +46,9 @@ var sorter_default = () => {
       title: "Age",
       dataIndex: "age",
       key: "age",
-      sorter: true,
-      defaultSortOrder: "descend"
+      sorter: {
+        defaultSortOrder: "descend"
+      }
     },
     {
       title: "Address",

package/dist/cjs/Table/hooks/useExpand.d.ts

@@ -1,5 +1,5 @@
-import { ExpandableType } from '../interface';
-export default function useExpand(expandable: ExpandableType | undefined, allKeys: string[], getRowKey: (record: Record<string, any>) => string): {
+import { ExpandableType, SelectionKeyType } from '../interface';
+export default function useExpand(expandable: ExpandableType | undefined, allKeys: SelectionKeyType[], getRowKey: (record: Record<string, any>) => SelectionKeyType): {
     expandedRowKeys: (string | number)[];
     onExpand: ({ expanded, record, }: {
         expanded: boolean;

package/dist/cjs/Table/hooks/useFilter.d.ts

@@ -1,13 +1,19 @@
-type FilterValue = string | number;
+import type { ColumnProps, FilterValue } from '../interface';
 type FilterInput = FilterValue | FilterValue[];
 type FilterOptions = {
     dataIndex: string;
     value: FilterInput;
 };
-export default function useFilter({ data, }: {
+type FilterRecord = {
+    value: FilterInput;
+    dataIndex: string;
+};
+export default function useFilter({ data, columns, }: {
     data: Array<Record<string, unknown>>;
+    columns: ColumnProps[];
 }): {
     data: Record<string, unknown>[];
+    filterRecords: FilterRecord[];
     onFilter: ({ value, dataIndex }: FilterOptions) => void;
 };
 export {};

package/dist/cjs/Table/hooks/useFilter.js

@@ -43,39 +43,52 @@ var import_react = require("react");
 var isEmptyFilterValue = (value) => value === "" || Array.isArray(value) && value.length === 0;
 var normalizeValue = (value) => value === null || value === void 0 ? "" : String(value).toLowerCase();
 function useFilter({
-  data
+  data,
+  columns
 }) {
   const [filterRecords, setFilterRecords] = (0, import_react.useState)([]);
+  const columnMap = (0, import_react.useMemo)(
+    () => new Map(
+      columns.flatMap(
+        (column) => column.dataIndex ? [[column.dataIndex, column]] : []
+      )
+    ),
+    [columns]
+  );
+  (0, import_react.useEffect)(() => {
+    setFilterRecords((current) => {
+      const next = current.filter(({ dataIndex }) => columnMap.has(dataIndex));
+      return next.length === current.length ? current : next;
+    });
+  }, [columnMap]);
   const onFilter = ({ value, dataIndex }) => {
-    let newFilterMap = [...filterRecords];
-    if (isEmptyFilterValue(value)) {
-      newFilterMap = newFilterMap.filter(
-        (item) => item.dataIndex !== dataIndex
-      );
-    } else {
-      let exited = false;
-      newFilterMap = newFilterMap.map((item) => {
-        if (item.dataIndex === dataIndex) {
-          exited = true;
-          return __spreadProps(__spreadValues({}, item), { value });
-        }
-        return item;
-      });
-      if (!exited) {
-        newFilterMap.push({ dataIndex, value });
+    setFilterRecords((current) => {
+      if (isEmptyFilterValue(value)) {
+        return current.filter((item) => item.dataIndex !== dataIndex);
       }
-    }
-    setFilterRecords(newFilterMap);
+      const index = current.findIndex((item) => item.dataIndex === dataIndex);
+      if (index === -1) {
+        return [...current, { dataIndex, value }];
+      }
+      return current.map(
+        (item, itemIndex) => itemIndex === index ? __spreadProps(__spreadValues({}, item), { value }) : item
+      );
+    });
   };
   const filtered = (0, import_react.useMemo)(() => {
     const handled = filterRecords.filter(
-      ({ dataIndex, value }) => Boolean(dataIndex) && !isEmptyFilterValue(value)
+      ({ dataIndex, value }) => Boolean(dataIndex) && columnMap.has(dataIndex) && !isEmptyFilterValue(value)
     );
     if (!handled.length) {
       return data;
     }
     return data.filter((item) => {
-      return handled.some(({ dataIndex, value }) => {
+      return handled.every(({ dataIndex, value }) => {
+        var _a, _b;
+        const customFilter = (_b = (_a = columnMap.get(dataIndex)) == null ? void 0 : _a.filter) == null ? void 0 : _b.onFilter;
+        if (customFilter) {
+          return Array.isArray(value) ? value.some((filterValue) => customFilter(filterValue, item)) : customFilter(value, item);
+        }
         const targetValue = normalizeValue(item[dataIndex]);
         if (Array.isArray(value)) {
           return value.some(
@@ -85,9 +98,10 @@ function useFilter({
         return targetValue.includes(normalizeValue(value));
       });
     });
-  }, [data, filterRecords]);
+  }, [columnMap, data, filterRecords]);
   return {
     data: filtered,
+    filterRecords,
     onFilter
   };
 }

package/dist/cjs/Table/hooks/usePagination.js

@@ -119,14 +119,6 @@ function usePagination({
       pageSize: pageSize2
     });
   };
-  if (pagination === false) {
-    return {
-      pageData: data,
-      current: 1,
-      pageSize: data.length,
-      pagination: false
-    };
-  }
   const pageData = (0, import_react.useMemo)(() => {
     const total = data.length;
     if (total <= mergedPageSize)
@@ -139,6 +131,14 @@ function usePagination({
     const start = (current2 - 1) * mergedPageSize;
     return data.slice(start, start + mergedPageSize);
   }, [data, meregdCurrent, mergedPageSize]);
+  if (pagination === false) {
+    return {
+      pageData: data,
+      current: 1,
+      pageSize: data.length,
+      pagination: false
+    };
+  }
   return {
     pageData,
     current: meregdCurrent,

package/dist/cjs/Table/hooks/useSelection.d.ts

@@ -3,15 +3,15 @@ import type { RowSelectionType, SelectionKeyType } from '../interface';
 export default function useSelection({ pageData, dataSource: data, getRowKey, rowSelection, allKeys, }: {
     pageData: Array<Record<string, unknown>>;
     dataSource: Array<Record<string, unknown>>;
-    getRowKey: (record: Record<string, unknown>) => string;
+    getRowKey: (record: Record<string, unknown>) => SelectionKeyType;
     allKeys: Array<SelectionKeyType>;
     rowSelection?: RowSelectionType;
 }): {
     selectedRowKeys: (string | number)[];
     checkedAll: boolean;
-    pageDataRowKeys: string[];
+    pageDataRowKeys: SelectionKeyType[];
     onCheck: (checked: boolean, key: number | string) => void;
     onCheckAll: (event: ChangeEvent<HTMLInputElement>) => void;
     onRadioCheck: (checked: boolean, key: number | string) => void;
-    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onChange: (event: ChangeEvent<HTMLInputElement>, key: SelectionKeyType) => void;
 };

package/dist/cjs/Table/hooks/useSelection.js

@@ -62,19 +62,19 @@ function useSelection({
     onChange == null ? void 0 : onChange(rowKeys, rowRecords);
   };
   const getDisabledKeys = () => {
+    if (disabled === true) {
+      return pageData.map((record) => getRowKey(record));
+    }
     if (Array.isArray(disabled)) {
-      return disabled;
+      return pageData.filter((_, index) => disabled[index]).map((record) => getRowKey(record));
     }
     if (typeof disabled === "function") {
-      return Array.isArray(pageData) && pageData.filter((record, index) => disabled(record, index)).map((record) => getRowKey(record));
+      return pageData.filter((record, index) => disabled(record, index)).map((record) => getRowKey(record));
     }
     return [];
   };
-  const getPageDataRowKeys = () => {
-    return Array.isArray(pageData) && pageData.map((record) => getRowKey(record));
-  };
   const disabledKeys = getDisabledKeys();
-  const pageDataRowKeys = getPageDataRowKeys();
+  const pageDataRowKeys = pageData.map((record) => getRowKey(record));
   const isCheckedAll = () => {
     const filtered = pageDataRowKeys.filter(
       (key) => !disabledKeys.includes(key)
@@ -108,15 +108,14 @@ function useSelection({
     );
     setMergedSelectedRowKeys(rowKeys);
     onChange == null ? void 0 : onChange(rowKeys, rowRecords);
-    onSelectAll == null ? void 0 : onSelectAll(rowKeys, rowRecords, checked);
+    onSelectAll == null ? void 0 : onSelectAll(checked, rowKeys, rowRecords);
   };
   const onRadioCheck = (checked, key) => {
     const record = pageData.find((item) => getRowKey(item) === key);
     setMergedSelectedRowKeys([key]);
     onChange == null ? void 0 : onChange([key], record);
   };
-  const handleChange = (event) => {
-    const key = event.target.value;
+  const handleChange = (event, key) => {
     const checked = event.target.checked;
     if (type === "checkbox") {
       onCheck(checked, key);

package/dist/cjs/Table/hooks/useSorter.d.ts

@@ -1,6 +1,9 @@
 import { ColumnProps } from '../interface';
-type SortState = {
-    [dataIndex: string]: 0 | 1 | -1;
+type SortOrder = 1 | -1;
+type SortState = Record<string, SortOrder>;
+type SortChangeResult = {
+    data: Array<Record<string, unknown>>;
+    sorters: SortState;
 };
 export default function useSorter({ data, columns, }: {
     data: Array<Record<string, unknown>>;
@@ -8,6 +11,6 @@ export default function useSorter({ data, columns, }: {
 }): {
     data: Record<string, unknown>[];
     sorters: SortState;
-    onSort: (dataIndex: string) => void;
+    onSort: (dataIndex: string) => SortChangeResult;
 };
 export {};

package/dist/cjs/Table/hooks/useSorter.js

@@ -1,21 +1,7 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -37,85 +23,205 @@ __export(useSorter_exports, {
 });
 module.exports = __toCommonJS(useSorter_exports);
 var import_react = require("react");
+var getSorterConfig = (column) => column && typeof column.sorter === "object" ? column.sorter : void 0;
+var toSortOrder = (order) => {
+  if (order === "ascend")
+    return 1;
+  if (order === "descend")
+    return -1;
+  return 0;
+};
+var getNextSortOrder = (order) => {
+  if (order === 0)
+    return 1;
+  if (order === 1)
+    return -1;
+  return 0;
+};
+var isMultipleSorter = (column) => {
+  var _a;
+  return Boolean((_a = getSorterConfig(column)) == null ? void 0 : _a.multiple);
+};
+var applySortChange = (queue, column, order, columnMap) => {
+  var _a;
+  const { dataIndex } = column;
+  if (!dataIndex)
+    return queue;
+  if (order === 0) {
+    return queue.filter((item) => item.dataIndex !== dataIndex);
+  }
+  const multiple = (_a = getSorterConfig(column)) == null ? void 0 : _a.multiple;
+  const nextItem = { dataIndex, order };
+  if (!multiple) {
+    return [nextItem];
+  }
+  const next = queue.filter(
+    (item) => item.dataIndex === dataIndex || isMultipleSorter(columnMap.get(item.dataIndex))
+  );
+  const currentIndex = next.findIndex((item) => item.dataIndex === dataIndex);
+  if (currentIndex === -1) {
+    next.push(nextItem);
+  } else {
+    next[currentIndex] = nextItem;
+  }
+  if (typeof multiple === "number") {
+    const limit = Math.max(1, Math.floor(multiple));
+    while (next.length > limit) {
+      const removeIndex = next.findIndex(
+        (item) => item.dataIndex !== dataIndex
+      );
+      if (removeIndex === -1)
+        break;
+      next.splice(removeIndex, 1);
+    }
+  }
+  return next;
+};
+var normalizeQueue = (queue, columnMap) => queue.reduce((next, item) => {
+  const column = columnMap.get(item.dataIndex);
+  return column ? applySortChange(next, column, item.order, columnMap) : next;
+}, []);
+var areQueuesEqual = (a, b) => a.length === b.length && a.every(
+  (item, index) => {
+    var _a, _b;
+    return item.dataIndex === ((_a = b[index]) == null ? void 0 : _a.dataIndex) && item.order === ((_b = b[index]) == null ? void 0 : _b.order);
+  }
+);
+var createColumnMap = (columns) => new Map(
+  columns.filter((column) => Boolean(column.dataIndex && column.sorter)).map((column) => [column.dataIndex, column])
+);
+var createInitialQueue = (columns, columnMap) => columns.reduce((queue, column) => {
+  const config = getSorterConfig(column);
+  const order = toSortOrder(
+    (config == null ? void 0 : config.sortOrder) !== void 0 ? config.sortOrder : config == null ? void 0 : config.defaultSortOrder
+  );
+  return order ? applySortChange(queue, column, order, columnMap) : queue;
+}, []);
+var mergeControlledSorters = (queue, columns, columnMap) => {
+  const controlledOrders = /* @__PURE__ */ new Map();
+  columns.forEach((column) => {
+    const config = getSorterConfig(column);
+    if (column.dataIndex && (config == null ? void 0 : config.sortOrder) !== void 0) {
+      controlledOrders.set(column.dataIndex, toSortOrder(config.sortOrder));
+    }
+  });
+  const uncontrolledQueue = queue.filter(
+    (item) => !controlledOrders.has(item.dataIndex)
+  );
+  const controlledQueue = [];
+  queue.forEach((item) => {
+    const controlledOrder = controlledOrders.get(item.dataIndex);
+    if (controlledOrder === void 0)
+      return;
+    controlledOrders.delete(item.dataIndex);
+    if (controlledOrder) {
+      controlledQueue.push({
+        dataIndex: item.dataIndex,
+        order: controlledOrder
+      });
+    }
+  });
+  columns.forEach((column) => {
+    const { dataIndex } = column;
+    if (!dataIndex)
+      return;
+    const controlledOrder = controlledOrders.get(dataIndex);
+    if (controlledOrder) {
+      controlledQueue.push({ dataIndex, order: controlledOrder });
+    }
+  });
+  return normalizeQueue([...uncontrolledQueue, ...controlledQueue], columnMap);
+};
+var queueToSortState = (queue) => Object.fromEntries(
+  queue.map(({ dataIndex, order }) => [dataIndex, order])
+);
+var compareValues = (a, b) => {
+  if (Object.is(a, b))
+    return 0;
+  if (typeof a === "number" && typeof b === "number")
+    return a - b;
+  if (typeof a === "bigint" && typeof b === "bigint")
+    return a < b ? -1 : 1;
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() - b.getTime();
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return Number(a) - Number(b);
+  }
+  return String(a).localeCompare(String(b));
+};
+var sortData = (data, queue, columnMap) => {
+  if (!queue.length)
+    return data;
+  return [...data].sort((a, b) => {
+    var _a;
+    for (const { dataIndex, order } of queue) {
+      const aValue = a[dataIndex];
+      const bValue = b[dataIndex];
+      const compare = (_a = getSorterConfig(columnMap.get(dataIndex))) == null ? void 0 : _a.sort;
+      if (compare) {
+        const result2 = compare(a, b);
+        if (result2 !== 0) {
+          return order === -1 ? -result2 : result2;
+        }
+        continue;
+      }
+      if (aValue === null && bValue === null)
+        continue;
+      if (aValue === null || aValue === void 0)
+        return 1;
+      if (bValue === null || bValue === void 0)
+        return -1;
+      const result = compareValues(aValue, bValue);
+      if (result !== 0) {
+        return order === -1 ? -result : result;
+      }
+    }
+    return 0;
+  });
+};
 function useSorter({
   data,
   columns
 }) {
-  const getDefaultSorters = (0, import_react.useCallback)(() => {
-    const sorters2 = {};
-    columns.forEach((column) => {
-      const { dataIndex, sorter } = column;
-      if (!sorter)
-        return;
-      const { defaultSortOrder } = typeof sorter === "boolean" ? {} : sorter;
-      if (dataIndex && sorter) {
-        if (defaultSortOrder === "ascend") {
-          sorters2[dataIndex] = 1;
-        } else if (defaultSortOrder === "descend") {
-          sorters2[dataIndex] = -1;
-        } else {
-          sorters2[dataIndex] = 0;
-        }
-      }
-    });
-    return sorters2;
-  }, [columns]);
-  const [sorters, setSorters] = (0, import_react.useState)(getDefaultSorters());
+  const columnMap = (0, import_react.useMemo)(() => createColumnMap(columns), [columns]);
+  const [internalQueue, setInternalQueue] = (0, import_react.useState)(
+    () => createInitialQueue(columns, columnMap)
+  );
   (0, import_react.useEffect)(() => {
-    setSorters(getDefaultSorters());
-  }, [getDefaultSorters]);
-  const onSort = (dataIndex) => {
-    setSorters((prev) => {
-      var _a;
-      const newSorters = __spreadValues({}, prev);
-      const currentOrder = (_a = newSorters[dataIndex]) != null ? _a : 0;
-      if (currentOrder === 0) {
-        newSorters[dataIndex] = 1;
-      } else if (currentOrder === 1) {
-        newSorters[dataIndex] = -1;
-      } else {
-        newSorters[dataIndex] = 0;
-      }
-      const isMultipleSort = void 0;
-      if (isMultipleSort) {
-      } else {
-        Object.keys(newSorters).forEach((key) => {
-          if (key !== dataIndex) {
-            delete newSorters[key];
-          }
-        });
-      }
-      return newSorters;
-    });
-  };
-  const sorted = (0, import_react.useMemo)(() => {
-    const activeSorters = Object.entries(sorters).filter(
-      ([, order]) => order !== 0
-    );
-    if (activeSorters.length === 0) {
-      return data;
-    }
-    const sortedData = [...data].sort((a, b) => {
-      for (const [dataIndex, order] of activeSorters) {
-        const aValue = a[dataIndex];
-        const bValue = b[dataIndex];
-        if (aValue === null && bValue === null)
-          continue;
-        if (aValue === null || aValue === void 0)
-          return 1;
-        if (bValue === null || bValue === void 0)
-          return -1;
-        if (aValue < bValue) {
-          return order === -1 ? 1 : -1;
-        }
-        if (aValue > bValue) {
-          return order === -1 ? -1 : 1;
-        }
-      }
-      return 0;
+    setInternalQueue((current) => {
+      const next = normalizeQueue(current, columnMap);
+      return areQueuesEqual(current, next) ? current : next;
     });
-    return sortedData;
-  }, [data, sorters]);
+  }, [columnMap]);
+  const activeQueue = (0, import_react.useMemo)(
+    () => mergeControlledSorters(internalQueue, columns, columnMap),
+    [internalQueue, columns, columnMap]
+  );
+  const sorters = (0, import_react.useMemo)(() => queueToSortState(activeQueue), [activeQueue]);
+  const sorted = (0, import_react.useMemo)(
+    () => sortData(data, activeQueue, columnMap),
+    [data, activeQueue, columnMap]
+  );
+  const onSort = (0, import_react.useCallback)(
+    (dataIndex) => {
+      var _a, _b;
+      const column = columnMap.get(dataIndex);
+      if (!column)
+        return { data: sorted, sorters };
+      const currentOrder = (_b = (_a = activeQueue.find((item) => item.dataIndex === dataIndex)) == null ? void 0 : _a.order) != null ? _b : 0;
+      const nextQueue = applySortChange(
+        activeQueue,
+        column,
+        getNextSortOrder(currentOrder),
+        columnMap
+      );
+      const nextSorters = queueToSortState(nextQueue);
+      const nextData = sortData(data, nextQueue, columnMap);
+      setInternalQueue(nextQueue);
+      return { data: nextData, sorters: nextSorters };
+    },
+    [activeQueue, columnMap, data, sorted, sorters]
+  );
   return {
     data: sorted,
     sorters,

package/dist/cjs/Table/interface.d.ts

@@ -23,7 +23,7 @@ export interface ExpandableType {
     /**
      * Default expanded rows
      */
-    defaultExpandedRowKeys?: string[];
+    defaultExpandedRowKeys?: SelectionKeyType[];
     /**
      * Expanded rows
      */
@@ -51,6 +51,7 @@ export interface ExpandableType {
     expandedRowRender?: (record: object, index: number, page: Record<string, any>) => React.ReactNode;
 }
 export type SelectionKeyType = string | number;
+export type FilterValue = string | number;
 export type ColumnSemanticType = 'inner' | 'action';
 export interface HeadCellProps extends Omit<WrapedColumnProps, 'title'> {
     prefixCls?: string;
@@ -186,7 +187,7 @@ export interface ColumnProps {
         /**
          * Filter callback function
          */
-        onFilter?: (value: string, record: Record<string, any>) => boolean;
+        onFilter?: (value: FilterValue, record: Record<string, any>) => boolean;
     };
     /**
      * Sorter config
@@ -195,9 +196,10 @@ export interface ColumnProps {
         /**
          * Sort function
          */
-        sort?: () => number | boolean;
+        sort?: (a: Record<string, unknown>, b: Record<string, unknown>) => number;
         /**
-         * Whether to support multi-column sort, if set to a number, it indicates the number of sortable columns
+         * Enable multi-column sorting. A positive number limits the active
+         * sorters; when exceeded, the earliest activated sorter is removed.
          */
         multiple?: boolean | number;
         /**
@@ -359,6 +361,7 @@ export interface TableRowProps {
     pageSize: number;
     index: number;
     record: Record<string, any>;
+    rowKeyValue: SelectionKeyType;
     columns: ColumnProps[];
     expandable?: ExpandableType;
     expandedRowKeys?: Array<string | number>;
@@ -375,7 +378,7 @@ export interface TableRowProps {
         record: Record<string, any>;
         index: number;
     }) => void;
-    onSelectionChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onSelectionChange: (event: ChangeEvent<HTMLInputElement>, key: SelectionKeyType) => void;
 }
 type LazyLoadType = {
     lazyLoadRows?: number;
@@ -389,7 +392,7 @@ export interface LazyRowProps extends TableRowProps {
     };
     lazyLoad?: boolean | LazyLoadType;
 }
-export interface TableBodyProps extends Omit<LazyRowProps, 'index' | 'record'> {
+export interface TableBodyProps extends Omit<LazyRowProps, 'index' | 'record' | 'rowKeyValue'> {
     pageData: Array<Record<string, any>>;
     noData?: React.ReactNode;
 }
@@ -542,7 +545,7 @@ export interface TableProps extends FooterProps, Omit<HeaderProps, 'pageData'>,
      * Set the unique key for rows
      * @default id
      */
-    rowKey?: string | ((record: Record<string, any>) => string);
+    rowKey?: string | ((record: Record<string, any>) => SelectionKeyType);
     /**
      * Summary bar
      */