dcp-design-react 1.7.42

package/lib/table/src/export/define.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+type IDefineProps = {
+    columns: IColumn[];
+    onChange: (columns: IColumn[]) => void;
+};
+declare const Define: React.FC<IDefineProps>;
+export default Define;

package/lib/table/src/export/index.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { IColumn, ToolMethodRef } from '../table/types';
+export type IOptions = {
+    fileName: string;
+    fileType: 'xlsx' | 'csv';
+    sheetName: string;
+    exportType: 'all' | 'selected' | 'custom';
+    columns: IColumn[];
+    startIndex: number;
+    endIndex: number;
+    footSummation: boolean;
+    useStyle: boolean;
+};
+type ITableExportProps = {
+    tableColumns: IColumn[];
+    open?: boolean;
+};
+declare const TableExport: React.ForwardRefExoticComponent<ITableExportProps & React.RefAttributes<ToolMethodRef>>;
+export default TableExport;

package/lib/table/src/export/setting.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+type ISettingProps = {
+    defaultValue: {
+        fileName: string;
+        fileType: string;
+        columns: IColumn[];
+        useStyle: number;
+    };
+    onClose: () => void;
+    onOk: (data: any) => void;
+};
+declare const Setting: React.FC<ISettingProps>;
+export default Setting;

package/lib/table/src/export/useExport.d.ts

@@ -0,0 +1,13 @@
+import type { IColumn, IRecord } from '../table/types';
+import type { IOptions } from './index';
+type IParamsFn1 = (columns: IColumn[], tableData: IRecord[]) => Record<string, number>[];
+type IParamsFn2 = (row: IRecord, rowIndex: number, column: IColumn, columnIndex: number) => string | number;
+declare const useExport: () => {
+    exportXLSX: (options: IOptions, dataList: IRecord[], calcSummationValues: IParamsFn1, renderCell: IParamsFn2) => Promise<Blob>;
+    exportCSV: (options: IOptions, tableHTML: string) => Blob;
+    importXLSX: (options: {
+        columns: IColumn[];
+        file: Blob;
+    }, callback?: ((records: IRecord[]) => void) | undefined) => void;
+};
+export default useExport;

package/lib/table/src/fast-search/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { ToolMethodRef } from '../table/types';
+type IFastSearchProps = {
+    open?: boolean;
+};
+declare const FastSearch: React.ForwardRefExoticComponent<IFastSearchProps & React.RefAttributes<ToolMethodRef>>;
+export default FastSearch;

package/lib/table/src/fast-search/setting.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type ISettingProps = {
+    onClose: () => void;
+};
+declare const Setting: React.FC<ISettingProps>;
+export default Setting;

package/lib/table/src/filter/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn, IFilter } from '../table/types';
+type IHeadFilterProps = {
+    column: IColumn;
+    filters: IFilter;
+};
+declare const HeadFilter: React.FC<IHeadFilterProps>;
+export default HeadFilter;

package/lib/table/src/filter-sql/index.d.ts

@@ -0,0 +1,5 @@
+import type { IRecord } from '../table/types';
+export declare const stringify: (string: any, separator?: string) => any;
+export declare const array_format: (array: any) => string;
+export declare const isBracketBalance: (str: any) => boolean;
+export declare const where: <T extends IRecord<any>>(array: T[], query: string, isTree?: boolean) => T[];

package/lib/table/src/filter-sql/lib/filter_string.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    operations: (string: any) => any[];
+    number_operations: (string: any) => any;
+    string_format: (string: any) => any;
+    stringify: (string: any, separator?: string) => any;
+    array_format: (array: any) => string;
+    operation_format: (string: any) => any;
+    find_replace: (string: any, find: any, replace: any) => any;
+    replace_symbols: (string: any) => any;
+};
+export default _default;

package/lib/table/src/filter-sql/lib/operations.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 解析 where 条件的各种情况
+ * @param {any} value 数据值
+ * @param {string} expression 标记符
+ * @param {any} condition 条件值
+ * @returns {boolean}
+ */
+export declare const matchWhere: (value: any, expression: string, condition: any) => boolean;

package/lib/table/src/filter-sql/lib/variables_replacement.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    isBracketBalance: (str: any) => boolean;
+    replace_variables: (string: any, variable: any) => any;
+};
+export default _default;

package/lib/table/src/footer/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IColumn } from '../table/types';
+type IFootProps = {
+    summationRows: Record<string, string | number>[];
+    flattenColumns: IColumn[];
+};
+declare const TableFooter: React.FC<IFootProps>;
+export default TableFooter;

package/lib/table/src/full-screen/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ToolMethodRef } from '../table/types';
+type IFullScreenProps = {
+    isFullScreen: boolean;
+    open?: boolean;
+};
+declare const FullScreen: React.ForwardRefExoticComponent<IFullScreenProps & React.RefAttributes<ToolMethodRef>>;
+export default FullScreen;

package/lib/table/src/group-summary/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { ToolMethodRef } from '../table/types';
+type IGroupSummaryProps = {
+    open?: boolean;
+};
+declare const GroupSummary: React.ForwardRefExoticComponent<IGroupSummaryProps & React.RefAttributes<ToolMethodRef>>;
+export default GroupSummary;

package/lib/table/src/group-summary/result.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { IColumn, IRecord } from '../table/types';
+type IResultProps = {
+    columns: IColumn[];
+    group: IRecord[];
+    summary: IRecord[];
+};
+declare const Result: React.FC<IResultProps>;
+export default Result;

package/lib/table/src/group-summary/setting.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type ISettingProps = {
+    onClose: () => void;
+};
+declare const Setting: React.FC<ISettingProps>;
+export default Setting;

package/lib/table/src/header/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IColumn, IFilter, ISorter } from '../table/types';
+type IHeaderProps = {
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    sorter: ISorter;
+    filters: IFilter;
+};
+declare const TableHeader: React.FC<IHeaderProps>;
+export default TableHeader;

package/lib/table/src/hooks/useImperativeMethod.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { getRowKeyType, ITableProps, IColumn, IFetchParams, IPagination, IRecord, IRowKey, IRule, IValidItem, TableRef, ToolBoxRef, TableBodyRef } from '../table/types';
+type IExtra = {
+    getRowKey: getRowKeyType;
+    tableProps: ITableProps;
+    tableRef: React.MutableRefObject<ITableRef>;
+    toolBoxRef: React.RefObject<ToolBoxRef>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    flattenColumns: IColumn[];
+    editableColumns: IColumn[];
+    pagination: IPagination;
+    fetchParams: IFetchParams;
+    selectionKeys: IRowKey[];
+    rowExpandedKeys: IRowKey[];
+    highlightKey: IRowKey;
+    isFetch: boolean;
+    dataChange: () => void;
+    getTableData: () => Promise<void>;
+    handleTableData: (records: IRecord[]) => void;
+    createTableData: (records: IRecord[]) => void;
+    calcTableHeight: () => void;
+    scrollXToColumn: (dataIndex: string, index?: number) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number) => void;
+    doFieldValidate: (rules: IRule[], val: unknown, rowKey: IRowKey, columnKey: string) => void;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    forceUpdate: () => void;
+    setSelectionKeysEffect: (rowKeys: IRowKey[]) => void;
+    setRowExpandedKeys: (rowKeys: IRowKey[]) => void;
+    setHighlightKey: (rowKey: IRowKey) => void;
+    setSelectionRows: (records: IRecord[]) => void;
+    setOriginColumns: (columns: IColumn[]) => void;
+    setHandleChange: (value: boolean) => void;
+    getTableLog: () => {
+        required: IValidItem[];
+        validate: IValidItem[];
+        inserted: IRecord[];
+        updated: IRecord[];
+        removed: IRecord[];
+    };
+    clearRowSelection: () => void;
+    clearRowHighlight: () => void;
+    clearTableSorter: () => void;
+    clearTableFilter: () => void;
+    clearSuperFilters: () => void;
+    clearTableLog: () => void;
+};
+declare const useImperativeMethod: <T extends React.ForwardedRef<TableRef>>(ref: T, extra: IExtra) => void;
+export default useImperativeMethod;

package/lib/table/src/hooks/useTableCore.d.ts

@@ -0,0 +1,93 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { ITableState } from './useTableState';
+import type { getRowKeyType, IColumn, IDerivedRowKey, IFetchParams, IFieldAuthItem, IFilter, IPagination, IRecord, IRowKey, IRule, ISorter, ISuperFilter, ITableProps, IValidItem, TableBodyRef } from '../table/types';
+import type { ComponentSize } from '../../../_utils/types';
+type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    tableElementRef: React.RefObject<HTMLElement>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    $size: ComponentSize;
+    tableColumns: IColumn[];
+    tableFullData: IRecord[];
+    pagination: IPagination;
+    layout: ITableState['layout'];
+    filters: IFilter;
+    sorter: ISorter;
+    superFilters: ISuperFilter[];
+    fetchParams: IFetchParams;
+    selectionKeys: IRowKey[];
+    rowExpandedKeys: IRowKey[];
+    highlightKey: IRowKey;
+    summationColumns: IColumn[];
+    shouldUpdateHeight: boolean;
+    isFetch: boolean;
+    isTreeTable: boolean;
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    isServiceSummation: boolean;
+    isGroupSubtotal: boolean;
+    doLayout: () => void;
+    setTableData: (records: IRecord[]) => void;
+    setTableFullData: (records: IRecord[]) => void;
+    setTableOriginData: (records: IRecord[]) => void;
+    setAllTableData: (records: IRecord[]) => void;
+    setDeriveRowKeys: (records: IRecord[]) => void;
+    setPagination: <T extends IPagination>(pagination: T | ((prev: T) => T)) => void;
+    setSpinning: (value: boolean) => void;
+    setSorter: (sorter: ITableState['sorter']) => void;
+    setFilters: (sorter: ITableState['filters']) => void;
+    setSuperFilters: (options: ITableState['superFilters']) => void;
+    setSelectionKeys: (rowKeys: IRowKey[]) => void;
+    setRowExpandedKeys: (rowKeys: IRowKey[]) => void;
+    setHighlightKey: (rowKey: IRowKey) => void;
+    setSelectionRows: (records: IRecord[]) => void;
+    setScrollYLoad: (scrollYLoad: boolean) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+    setFieldAuth: (key: string, value: IFieldAuthItem) => void;
+    setResizeState: (option: ITableRef['resizeState']) => void;
+    setSummaries: (option: ITableRef['summaries']) => void;
+    setPermission: <T extends ITableState['permission']>(option: T | ((prev: T) => T)) => void;
+    setRecordsMap: (key: IRowKey, value: IRecord) => void;
+    resetTableScroll: () => void;
+    clearElementStore: () => void;
+    clearRecordsMap: () => void;
+};
+declare const useTableCore: <T extends ITableProps>(props: T, extra: IExtra) => {
+    initialTable: () => void;
+    createTableFullData: (list: IRecord[]) => void;
+    getTableData: () => Promise<void>;
+    handleTableData: (dataList: IRecord[]) => void;
+    createTableData: (list: IRecord[]) => void;
+    createGroupData: (list: IRecord[]) => IRecord<any>[];
+    createSelectionKeys: (rowKeys?: IRowKey[]) => (string | number)[];
+    createRowExpandedKeys: (rowKeys?: IRowKey[]) => (string | number)[];
+    setSelectionKeysEffect: (selectedKeys: IRowKey[]) => void;
+    findParentRowKeys: (deriveRowKeyList: IDerivedRowKey[], key: IRowKey) => (string | number)[];
+    getAllChildRowKeys: (deriveRowKeyList: IDerivedRowKey[]) => (string | number)[];
+    doFieldValidate: (rules: IRule[], val: unknown, rowKey: IRowKey, columnKey: string) => void;
+    getTableLog: () => {
+        required: IValidItem[];
+        validate: IValidItem[];
+        inserted: IRecord<any>[];
+        updated: IRecord<any>[];
+        removed: IRecord<any>[];
+    };
+    dataChange: () => void;
+    tableChange: (...args: any[]) => void;
+    toLastPage: () => void;
+    toFirstPage: () => void;
+    getPageCount: () => number;
+    pagerChangeHandle: ({ current, pageSize }: Omit<IPagination, 'total'>) => void;
+    triggerScrollYEvent: (st: number) => void;
+    scrollBottomDebouncer: (...args: any[]) => void;
+    clearTableSorter: () => void;
+    clearTableFilter: () => void;
+    clearSuperFilters: () => void;
+    clearRowSelection: () => void;
+    clearRowHighlight: () => void;
+    clearTableLog: () => void;
+    destroy: () => void;
+};
+export default useTableCore;

package/lib/table/src/hooks/useTableEffect.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import type { ITableRef } from './useTableRef';
+import type { TableBodyRef, IColumn, IPagination, IRowKey, ITableProps, IMergeCell } from '../table/types';
+import type { ComponentSize } from '../../../_utils/types';
+type IExtra = {
+    tableRef: React.MutableRefObject<ITableRef>;
+    topElementRef: React.RefObject<HTMLDivElement>;
+    tableElementRef: React.RefObject<HTMLDivElement>;
+    tableBodyRef: React.RefObject<TableBodyRef>;
+    resizableBarRef: React.RefObject<HTMLDivElement>;
+    $size: ComponentSize;
+    scrollX: boolean;
+    pagination: IPagination;
+    selectionKeys: IRowKey[];
+    rowExpandedKeys: IRowKey[];
+    highlightKey: IRowKey;
+    summationRows: Record<string, number | string>[];
+    showSummary: boolean;
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    isTreeTable: boolean;
+    toLastPage: () => void;
+    toFirstPage: () => void;
+    getPageCount: () => number;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number) => void;
+    setOriginColumns: (columns: IColumn[]) => void;
+    setSelectionKeysEffect: (rowKeys: IRowKey[]) => void;
+    setRowExpandedKeys: (rowKeys: IRowKey[]) => void;
+    setHighlightKey: (rowKey: IRowKey) => void;
+    setResizeState: (option: ITableRef['resizeState']) => void;
+    setMergeCells: (values: IMergeCell[]) => void;
+    setPingRight: (value: boolean) => void;
+    setUnMounted: (value: boolean) => void;
+    setHandleChange: (value: boolean) => void;
+    calcTableHeight: () => void;
+    createSelectionKeys: (rowKeys?: IRowKey[]) => IRowKey[];
+    createRowExpandedKeys: (rowKeys?: IRowKey[]) => IRowKey[];
+    createElementStore: (option: Record<string, HTMLElement>) => void;
+    triggerScrollYEvent: (st: number) => void;
+    initialTable: () => void;
+    destroy: () => void;
+};
+declare const useTableEffect: <T extends ITableProps>(props: T, extra: IExtra) => void;
+export default useTableEffect;

package/lib/table/src/hooks/useTableLayout.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { getRowKeyType } from '../table/types';
+import type { IColumn, IRecord, IRowKey, ITableProps } from '../table/types';
+import type { ITableState } from './useTableState';
+import type { ITableRef } from './useTableRef';
+import type { ComponentSize } from '../../../_utils/types';
+type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    $size: ComponentSize;
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    leftFixedColumns: IColumn[];
+    layout: ITableState['layout'];
+    scrollY: boolean;
+    tableData: IRecord[];
+    showFooter: boolean;
+    showPagination: boolean;
+    isWebPagination: boolean;
+    isFullScreen: boolean;
+    setLayout: <T extends ITableState['layout']>(layout: T | ((prev: T) => T)) => void;
+    setScrollX: (scrollX: boolean) => void;
+    setScrollY: (scrollY: boolean) => void;
+    setElementStore: (key: string, value: HTMLElement) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+    setShouldToTop: (value: boolean) => void;
+};
+declare const useTableLayout: <T extends ITableProps>(props: T, extra: IExtra) => {
+    createElementStore: (option: Record<string, HTMLElement>) => void;
+    tableStyles: React.CSSProperties;
+    getSpan: (row: IRecord, column: IColumn, rowIndex: number, columnIndex: number, tableData: IRecord[]) => {
+        rowSpan: number;
+        colSpan: number;
+    };
+    getStickyLeft: (dataIndex: string) => number;
+    getStickyRight: (dataIndex: string) => number;
+    scrollXToColumn: (dataIndex: string, index?: number) => void;
+    scrollYToRecord: (rowKey: IRowKey, index?: number) => void;
+    rowInViewport: (index: number) => boolean;
+    calcTableHeight: () => void;
+    resetTableScroll: () => void;
+    doLayout: () => void;
+};
+export default useTableLayout;

package/lib/table/src/hooks/useTableMemo.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { ITableProps, IColumn, IRowKey, IRecord, getRowKeyType, IFetchParams, ISorter, IFilter, IPagination, ISuperFilter } from '../table/types';
+import type { ITableRef } from './useTableRef';
+type IExtra = {
+    getRowKey: getRowKeyType;
+    tableRef: React.MutableRefObject<ITableRef>;
+    tableFullData: IRecord[];
+    tableData: IRecord[];
+    sorter: ISorter;
+    filters: IFilter;
+    superFilters: ISuperFilter[];
+    selectionKeys: IRowKey[];
+    pagination: IPagination;
+};
+declare const useTableMemo: <T extends ITableProps>(props: T, extra: IExtra) => {
+    isFetch: boolean;
+    isWebPagination: boolean;
+    isScrollPagination: boolean;
+    showPagination: boolean;
+    shouldUpdateHeight: boolean;
+    tableColumns: IColumn[];
+    flattenColumns: IColumn[];
+    editableColumns: IColumn[];
+    summationColumns: IColumn[];
+    leftFixedColumns: IColumn[];
+    rightFixedColumns: IColumn[];
+    treeExpandIndex: string;
+    showSummary: boolean;
+    showFooter: boolean;
+    isHeadGroup: boolean;
+    bordered: boolean;
+    isHeadSorter: boolean;
+    isHeadFilter: boolean;
+    isServiceSummation: boolean;
+    isSelectCollection: boolean;
+    isTableImport: boolean;
+    isTableClipboard: boolean;
+    isSuperSearch: boolean;
+    isFastSearch: boolean;
+    isGroupSummary: boolean;
+    isGroupSubtotal: boolean;
+    isDragMergeCell: boolean;
+    isTreeTable: boolean;
+    isTableEmpty: boolean;
+    summationRows: Record<string, string | number>[];
+    fetchParams: IFetchParams;
+};
+export default useTableMemo;

package/lib/table/src/hooks/useTableRef.d.ts

@@ -0,0 +1,111 @@
+import React from 'react';
+import Store from '../store';
+import type { getRowKeyType, IColumn, IDerivedRowKey, IFieldAuthItem, IMergeCell, InsertMode, IRecord, IRowKey, ITableProps } from '../table/types';
+import type { ComponentSize, Nullable } from '../../../_utils/types';
+export type ITableRef = {
+    uid: string;
+    elementStore: Record<string, Nullable<HTMLElement>>;
+    originColumns: IColumn[];
+    tableFullData: IRecord[];
+    tableOriginData: IRecord[];
+    allTableData: IRecord[];
+    allRowKeys: IRowKey[];
+    deriveRowKeys: IDerivedRowKey[];
+    flattenRowKeys: IRowKey[];
+    invalidRowKeys: IRowKey[];
+    fieldAuth: Record<string, IFieldAuthItem>;
+    mergeCells: IMergeCell[];
+    scrollYStore: {
+        startIndex: number;
+        endIndex: number;
+        offsetSize: number;
+        visibleSize: number;
+        rowHeight: number;
+    };
+    store: Store;
+    resizeState: {
+        width: number;
+        height: number;
+        winHeight: number;
+    };
+    handleState: {
+        insert: InsertMode | null;
+        remove: boolean;
+    };
+    summaries: Record<string, number>;
+    treeTable: boolean;
+    scrollYLoad: boolean;
+    shouldToTop: boolean;
+    selectionRows: IRecord[];
+    recordsMap: Map<IRowKey, IRecord>;
+    unMounted: boolean;
+    isHandleChange: boolean;
+    isIE: boolean;
+};
+type IExtra = {
+    getRowKey: getRowKeyType;
+    $size: ComponentSize;
+};
+declare const useTableRef: <T extends ITableProps>(props: T, { getRowKey, $size }: IExtra) => {
+    setElementStore: (key: string, value: HTMLElement) => void;
+    setOriginColumns: (columns: IColumn[]) => void;
+    setTableFullData: (records: IRecord[]) => void;
+    setTableOriginData: (records: IRecord[]) => void;
+    setAllTableData: (records: IRecord[]) => void;
+    setDeriveRowKeys: (records: IRecord[]) => void;
+    setInvalidRowKeys: (rowKeys: IRowKey[]) => void;
+    setFieldAuth: (key: string, value: IFieldAuthItem) => void;
+    setMergeCells: (values: IMergeCell[]) => void;
+    setScrollYStore: (option: ITableRef['scrollYStore']) => void;
+    setResizeState: (option: ITableRef['resizeState']) => void;
+    setHandleState: (option: ITableRef['handleState']) => void;
+    setSummaries: (option: ITableRef['summaries']) => void;
+    setScrollYLoad: (value: boolean) => void;
+    setShouldToTop: (value: boolean) => void;
+    setSelectionRows: (selectKeys: IRecord[]) => void;
+    setRecordsMap: (key: IRowKey, value: IRecord) => void;
+    setUnMounted: (value: boolean) => void;
+    setHandleChange: (value: boolean) => void;
+    clearElementStore: () => void;
+    clearRecordsMap: () => void;
+    uid: string;
+    elementStore: Record<string, Nullable<HTMLElement>>;
+    originColumns: IColumn[];
+    tableFullData: IRecord[];
+    tableOriginData: IRecord[];
+    allTableData: IRecord[];
+    allRowKeys: IRowKey[];
+    deriveRowKeys: IDerivedRowKey[];
+    flattenRowKeys: IRowKey[];
+    invalidRowKeys: IRowKey[];
+    fieldAuth: Record<string, IFieldAuthItem>;
+    mergeCells: IMergeCell[];
+    scrollYStore: {
+        startIndex: number;
+        endIndex: number;
+        offsetSize: number;
+        visibleSize: number;
+        rowHeight: number;
+    };
+    store: Store;
+    resizeState: {
+        width: number;
+        height: number;
+        winHeight: number;
+    };
+    handleState: {
+        insert: InsertMode | null;
+        remove: boolean;
+    };
+    summaries: Record<string, number>;
+    treeTable: boolean;
+    scrollYLoad: boolean;
+    shouldToTop: boolean;
+    selectionRows: IRecord[];
+    recordsMap: Map<IRowKey, IRecord>;
+    unMounted: boolean;
+    isHandleChange: boolean;
+    isIE: boolean;
+    tableRef: React.MutableRefObject<ITableRef>;
+};
+export default useTableRef;