@gx-design-vue/pro-table 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/_utils/ant-design-vue/index.d.ts

@@ -1,3 +1,5 @@
+export * from './spin/typings';
 export * from './pagination/typings';
 export * from './table/typings';
 export * from './table/props';
+export * from './input/typings';

package/dist/_utils/ant-design-vue/input/typings.d.ts

@@ -0,0 +1 @@
+export type { ChangeEvent } from 'ant-design-vue/es/_util/EventInterface';

package/dist/_utils/ant-design-vue/spin/typings.d.ts

@@ -0,0 +1 @@
+export type { SpinProps } from 'ant-design-vue';

package/dist/_utils/ant-design-vue/table/props.d.ts

@@ -1,2 +1,248 @@
-import { tableProps } from 'ant-design-vue/es/table';
-export { tableProps };
+import type { PropType } from 'vue';
+import type { SizeType } from '@gx-design-vue/pro-utils';
+import type { ColumnsType, TableLocale, FilterValue, SorterResult, TableCurrentDataSource, ColumnType, TableRowSelection, GetPopupContainer, SortOrder } from './typings';
+import type { ProTablePagination } from '../../../types/TableTypings';
+export declare const tableProps: () => {
+    prefixCls: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    columns: {
+        type: PropType<ColumnsType<any>>;
+        default: () => never[];
+    };
+    tableLayout: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").TableLayout | undefined>;
+        default: undefined;
+    };
+    rowClassName: {
+        type: PropType<string | import("ant-design-vue/es/vc-table/interface").RowClassName<any> | undefined>;
+        default: undefined;
+    };
+    title: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").PanelRender<any> | undefined>;
+        default: undefined;
+    };
+    footer: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").PanelRender<any> | undefined>;
+        default: undefined;
+    };
+    id: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    showHeader: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    components: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").TableComponents<any> | undefined>;
+        default: undefined;
+    };
+    customRow: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").GetComponentProps<any> | undefined>;
+        default: undefined;
+    };
+    customHeaderRow: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").GetComponentProps<import("ant-design-vue/es/vc-table/interface").ColumnType<any>[]> | undefined>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<"ltr" | "rtl" | undefined>;
+        default: undefined;
+    };
+    expandFixed: {
+        type: PropType<boolean | "right" | "left" | undefined>;
+        default: undefined;
+    };
+    expandColumnWidth: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    expandedRowKeys: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").Key[] | undefined>;
+        default: undefined;
+    };
+    defaultExpandedRowKeys: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").Key[] | undefined>;
+        default: undefined;
+    };
+    expandedRowRender: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").ExpandedRowRender<any> | undefined>;
+        default: undefined;
+    };
+    expandRowByClick: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    expandIcon: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").RenderExpandIcon<any> | undefined>;
+        default: undefined;
+    };
+    onExpand: {
+        type: PropType<((expanded: boolean, record: any) => void) | undefined>;
+        default: undefined;
+    };
+    onExpandedRowsChange: {
+        type: PropType<((expandedKeys: import("ant-design-vue/es/vc-table/interface").Key[]) => void) | undefined>;
+        default: undefined;
+    };
+    'onUpdate:expandedRowKeys': {
+        type: PropType<((expandedKeys: import("ant-design-vue/es/vc-table/interface").Key[]) => void) | undefined>;
+        default: undefined;
+    };
+    defaultExpandAllRows: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    indentSize: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    /** @deprecated Please use `EXPAND_COLUMN` in `columns` directly */
+    expandIconColumnIndex: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    showExpandColumn: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    expandedRowClassName: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").RowClassName<any> | undefined>;
+        default: undefined;
+    };
+    childrenColumnName: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    rowExpandable: {
+        type: PropType<((record: any) => boolean) | undefined>;
+        default: undefined;
+    };
+    sticky: {
+        type: PropType<boolean | import("ant-design-vue/es/vc-table/interface").TableSticky | undefined>;
+        default: undefined;
+    };
+    dropdownPrefixCls: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    dataSource: {
+        type: PropType<any[] | undefined>;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<boolean | Partial<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            spinning: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            size: PropType<import("ant-design-vue/es/spin/Spin").SpinSize>;
+            wrapperClassName: StringConstructor;
+            tip: import("vue-types").VueTypeValidableDef<any>;
+            delay: NumberConstructor;
+            indicator: import("vue-types").VueTypeValidableDef<any>;
+        }>>>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<SizeType>;
+        default: undefined;
+    };
+    locale: {
+        type: PropType<TableLocale>;
+        default: undefined;
+    };
+    onChange: {
+        type: PropType<(pagination: ProTablePagination, filters: Record<string, FilterValue | null>, sorter: SorterResult | SorterResult[], extra: TableCurrentDataSource) => void>;
+        default: undefined;
+    };
+    onResizeColumn: {
+        type: PropType<(w: number, col: ColumnType) => void>;
+        default: undefined;
+    };
+    rowSelection: {
+        type: PropType<TableRowSelection<any>>;
+        default: undefined;
+    };
+    getPopupContainer: {
+        type: PropType<GetPopupContainer>;
+        default: undefined;
+    };
+    scroll: {
+        type: PropType<{
+            x?: string | number | true | undefined;
+            y?: string | number | undefined;
+        } & {
+            scrollToFirstRowOnChange?: boolean | undefined;
+        }>;
+        default: undefined;
+    };
+    sortDirections: {
+        type: PropType<SortOrder[]>;
+        default: undefined;
+    };
+    showSorterTooltip: {
+        type: PropType<boolean | Partial<import("vue").ExtractPropTypes<{
+            title: import("vue-types").VueTypeValidableDef<any>;
+            trigger: PropType<import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType | import("ant-design-vue/es/tooltip/abstractTooltipProps").TriggerType[]>;
+            open: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            visible: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            placement: PropType<import("ant-design-vue/es/tooltip").TooltipPlacement>;
+            color: PropType<import("ant-design-vue/es/_util/type").LiteralUnion<import("ant-design-vue/es/_util/colors").PresetColorType>>;
+            transitionName: StringConstructor;
+            overlayStyle: {
+                type: PropType<import("vue").CSSProperties>;
+                default: import("vue").CSSProperties;
+            };
+            overlayInnerStyle: {
+                type: PropType<import("vue").CSSProperties>;
+                default: import("vue").CSSProperties;
+            };
+            overlayClassName: StringConstructor;
+            openClassName: StringConstructor;
+            prefixCls: StringConstructor;
+            mouseEnterDelay: NumberConstructor;
+            mouseLeaveDelay: NumberConstructor;
+            getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
+            arrowPointAtCenter: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            autoAdjustOverflow: {
+                type: PropType<boolean | import("ant-design-vue/es/tooltip").AdjustOverflow>;
+                default: boolean | import("ant-design-vue/es/tooltip").AdjustOverflow;
+            };
+            destroyTooltipOnHide: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            align: {
+                type: PropType<import("ant-design-vue/es/vc-trigger/interface").AlignType>;
+                default: import("ant-design-vue/es/vc-trigger/interface").AlignType;
+            };
+            builtinPlacements: {
+                type: PropType<import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements>;
+                default: import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements;
+            };
+            children: ArrayConstructor;
+            onVisibleChange: PropType<(vis: boolean) => void>;
+            'onUpdate:visible': PropType<(vis: boolean) => void>;
+            onOpenChange: PropType<(vis: boolean) => void>;
+            'onUpdate:open': PropType<(vis: boolean) => void>;
+        }>>>;
+        default: boolean;
+    };
+    transformCellText: {
+        type: PropType<import("ant-design-vue/es/vc-table/interface").TransformCellText<any> | undefined>;
+        default: undefined;
+    };
+};

package/dist/_utils/ant-design-vue/table/typings.d.ts

@@ -1,9 +1,10 @@
 import type { TableProps, ColumnType } from 'ant-design-vue/es/table';
-import type { FilterValue, SorterResult } from 'ant-design-vue/es/table/interface';
+import type { FilterValue, SorterResult, ColumnsType, TableLocale, TableCurrentDataSource, GetPopupContainer, SortOrder } from 'ant-design-vue/es/table/interface';
 import type { RecordType } from '@gx-design-vue/pro-utils';
+import type { TableProps as RcTableProps } from 'ant-design-vue/es/vc-table/Table';
 export type { TablePaginationConfig, TableRowSelection } from 'ant-design-vue/es/table/interface';
 export type { Key } from 'ant-design-vue/es/vc-table/interface';
 export type TableFilters = Record<string, FilterValue | null>;
 export type TableSorterRecord = SorterResult<RecordType>;
 export type TableSorter = TableSorterRecord | TableSorterRecord[];
-export type { TableProps, ColumnType, FilterValue, SorterResult };
+export type { TableProps, ColumnType, FilterValue, SorterResult, ColumnsType, TableLocale, TableCurrentDataSource, GetPopupContainer, RcTableProps, SortOrder };

package/dist/_utils/ant-design-vue/tooltip/typings.d.ts

@@ -0,0 +1 @@
+export type { TooltipProps } from 'ant-design-vue/es/tooltip';

package/dist/_utils/index.d.ts

@@ -1,4 +1,3 @@
 export { initDefaultProps } from 'ant-design-vue/es/_util/props-util';
 export { noteOnce, warning } from 'ant-design-vue/es/vc-util/warning';
-export * from './typings';
 export * from './ant-design-vue';

package/dist/components/ColumnSetting/style.d.ts

@@ -1,6 +1,3 @@
+import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 import type { ProAliasToken } from '@gx-design-vue/pro-provider';
-export interface ProToken extends ProAliasToken {
-    componentCls: string;
-}
-declare const _default: (_prefixCls?: string | import("vue").Ref<string> | undefined) => import("ant-design-vue/es/theme/internal").UseComponentStyleResult;
-export default _default;
+export declare const genColumnSettingStyle: GenerateStyle<ProAliasToken>;

package/dist/components/Form/index.d.ts

@@ -1,10 +1,11 @@
 import type { PropType } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
+import type { SearchConfig } from '../../types/TableTypings';
 import type { ProSearchMap } from '../../types/ColumnTypings';
 declare const ProTableForm: import("vue").DefineComponent<{
     search: {
-        type: PropType<import("../../types/TableTypings").SearchConfig | undefined>;
-        default: () => import("../../types/TableTypings").SearchConfig;
+        type: PropType<SearchConfig>;
+        default: () => SearchConfig;
     };
     modal: PropType<boolean | undefined>;
     searchMap: {
@@ -16,8 +17,8 @@ declare const ProTableForm: import("vue").DefineComponent<{
     defaultParams: PropType<RecordType>;
 }, () => import("ant-design-vue/es/_util/type").VueNode, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "search"[], "search", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     search: {
-        type: PropType<import("../../types/TableTypings").SearchConfig | undefined>;
-        default: () => import("../../types/TableTypings").SearchConfig;
+        type: PropType<SearchConfig>;
+        default: () => SearchConfig;
     };
     modal: PropType<boolean | undefined>;
     searchMap: {
@@ -30,7 +31,7 @@ declare const ProTableForm: import("vue").DefineComponent<{
 }>> & {
     onSearch?: ((...args: any[]) => any) | undefined;
 }, {
-    search: import("../../types/TableTypings").SearchConfig | undefined;
+    search: SearchConfig;
     searchMap: ProSearchMap<"text">[];
 }>;
 export default ProTableForm;

package/dist/components/Form/style.d.ts

@@ -1,6 +1,3 @@
+import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 import type { ProAliasToken } from '@gx-design-vue/pro-provider';
-export interface ProToken extends ProAliasToken {
-    componentCls: string;
-}
-declare const _default: (_prefixCls?: string | import("vue").Ref<string> | undefined) => import("ant-design-vue/es/theme/internal").UseComponentStyleResult;
-export default _default;
+export declare const genTableFormStyle: GenerateStyle<ProAliasToken>;

package/dist/components/ListToolBar/style.d.ts

@@ -1,6 +1,3 @@
+import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 import type { ProAliasToken } from '@gx-design-vue/pro-provider';
-export interface ProToken extends ProAliasToken {
-    componentCls: string;
-}
-declare const _default: (_prefixCls?: string | import("vue").Ref<string> | undefined) => import("ant-design-vue/es/theme/internal").UseComponentStyleResult;
-export default _default;
+export declare const genListToolBarStyle: GenerateStyle<ProAliasToken>;

package/dist/components/ToolBar/FullscreenIcon.d.ts

@@ -1,3 +1,2 @@
-import type { FunctionalComponent as FC } from 'vue';
-declare const FullScreenIcon: FC;
+declare const FullScreenIcon: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default FullScreenIcon;

package/dist/context/TableContext.d.ts

@@ -4,9 +4,9 @@ import type { SizeType } from '@gx-design-vue/pro-utils';
 import type { ProColumnsType } from '../types/ColumnTypings';
 import type { ColumnsState, SettingsAction } from '../hooks/useColumnSetting';
 import type { PaginationProps } from '../_utils';
-export type ContextType = any;
 export interface TableContextProps {
     columns?: ComputedRef<ProColumnsType>;
+    isMobile?: ComputedRef<boolean>;
     cacheColumns?: ComputedRef<ProColumnsType>;
     tableSize?: Ref<SizeType>;
     action?: {
@@ -21,6 +21,6 @@ export interface TableContextProps {
     changeColumns: (map: Record<string, ColumnsState>, fixed: boolean) => void;
     [key: string]: any;
 }
-export declare const useContext: <T>(contextInjectKey?: string | InjectionKey<ContextType>, defaultValue?: ContextType) => T;
-export declare const provideTableContext: (value: TableContextProps | ComputedRef<TableContextProps>) => void;
-export declare const useTableContext: () => Required<TableContextProps>;
+export declare const useContext: <T>(contextInjectKey?: string | InjectionKey<T>, defaultValue?: T | undefined) => T;
+export declare const provideTableContext: (value: TableContextProps) => void;
+export declare const useTableContext: (defaultValue?: Required<TableContextProps>) => Required<TableContextProps>;

package/dist/hooks/useColums.d.ts

@@ -9,12 +9,12 @@ export type ConfigColumns = {
 };
 type UseColumnsType = {
     scroll: ComputedRef<ProTableProps['scroll']>;
-    breakpoint: ComputedRef<boolean>;
+    breakpoint: ComputedRef<boolean | undefined>;
     columns: ComputedRef<ProColumnsType>;
 } & ConfigColumns;
 export declare function useConfigColumns(props: ProTableProps): ConfigColumns;
 export declare function useColumns({ scroll, columns, breakpoint, draggabled, autoScroll, neverScroll }: UseColumnsType): {
-    breakpoint: ComputedRef<boolean>;
+    breakpoint: ComputedRef<boolean | undefined>;
     getProColumns: ComputedRef<ProColumnType<import("../typing").DefaultRecordType>[]>;
     cacheProColumns: Ref<ProColumnsType<import("../typing").DefaultRecordType>>;
     setColumns: (columnList: ProColumnsType<import("../typing").DefaultRecordType>) => void;

package/dist/hooks/useFetchData.d.ts

@@ -1,19 +1,20 @@
 import type { ComputedRef, Ref } from 'vue';
-import type { SpinProps, TableSorter } from '../_utils';
 import type { RecordType } from '@gx-design-vue/pro-utils';
 import type { ProTableProps, ProTablePagination, ProTabelFeachParams, ProTablePaginationConfig } from '../types/TableTypings';
 import type { ProColumnsType } from '../types/ColumnTypings';
+import type { FilterValue, SorterResult, TableCurrentDataSource } from '../_utils/ant-design-vue/table/typings';
 interface ActionType {
-    getLoading: ComputedRef<boolean | SpinProps | undefined>;
+    loadingStatus: ComputedRef<boolean | undefined>;
     getPaginationInfo: ComputedRef<ProTablePagination>;
     setPagination: (info: Partial<ProTablePagination>) => void;
-    setLoading: (loading: boolean | SpinProps) => void;
+    setLoading: (loading: boolean) => void;
     setColumns: (columnList: ProColumnsType) => void;
     removeRowKeys: (keyList: (string | number)[]) => void;
     syncSelectedRows: (dataList: any[]) => void;
     columns: ComputedRef<ProColumnsType>;
     formParamsRef: RecordType;
     onBeforeSearchSubmit: ProTableProps['onBeforeSearchSubmit'];
+    hasCustomRender: ComputedRef<boolean>;
 }
 export type ConfigFetchData = {
     polling: ComputedRef<ProTableProps['polling']>;
@@ -24,15 +25,16 @@ export type ConfigFetchData = {
     dataSource: ComputedRef<ProTableProps['dataSource']>;
 };
 export declare function useConfigFetchData(props: ProTableProps): Omit<ConfigFetchData, 'waitRequest'>;
-export declare function useFetchData({ polling, request, postData, dataSource, waitRequest, debounceTime }: ConfigFetchData, { columns, getLoading, setLoading, setColumns, removeRowKeys, syncSelectedRows, formParamsRef, setPagination, getPaginationInfo, onBeforeSearchSubmit }: ActionType, emit: any): {
+export declare function useFetchData({ polling, request, postData, dataSource, waitRequest, debounceTime }: ConfigFetchData, { columns, loadingStatus, setLoading, setColumns, removeRowKeys, syncSelectedRows, formParamsRef, setPagination, getPaginationInfo, onBeforeSearchSubmit, hasCustomRender }: ActionType, emit: any): {
     getDataSourceRef: ComputedRef<RecordType[]>;
     isTreeDataRef: ComputedRef<boolean>;
     reSetDataList: (list: RecordType[]) => void;
-    changeDataValue: ({ key, params }: {
+    changeDataValue: ({ key, params, type }: {
         key?: string | undefined;
         params: RecordType;
+        type?: "update" | "add" | "delete" | undefined;
     }) => void;
-    handleTableChange: (pagination: ProTablePaginationConfig, filters: Record<string, any[] | null>, sorter: TableSorter) => void;
+    handleTableChange: (pagination: ProTablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult | SorterResult[], extra?: TableCurrentDataSource) => void;
     reload: (info?: ProTabelFeachParams) => Promise<void>;
 };
 export {};

package/dist/hooks/useLoading.d.ts

@@ -1,17 +1,9 @@
-import type { Ref } from 'vue';
+import { type Ref } from 'vue';
 import type { SpinProps } from '../_utils';
 export declare function useLoading({ emit, loading }: {
     loading: Ref<boolean | SpinProps | undefined>;
     emit: any;
 }): {
-    getLoading: import("vue").ComputedRef<boolean | {
-        prefixCls?: string | undefined;
-        spinning?: boolean | undefined;
-        size?: "small" | "default" | "large" | undefined;
-        wrapperClassName?: string | undefined;
-        tip?: string | undefined;
-        delay?: number | undefined;
-        indicator?: any;
-    }>;
-    setLoading: (loading: boolean | SpinProps) => void;
+    loadingStatus: import("vue").ComputedRef<boolean>;
+    setLoading: (loading: boolean) => void;
 };

package/dist/hooks/useRowSelection.d.ts

@@ -1,7 +1,7 @@
 import type { Ref } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
-import type { ProTableProps } from '../types/TableTypings';
-export declare function useRowSelection(rowKey: Ref<ProTableProps['rowKey']>, rowSelection: Ref<ProTableProps['rowSelection']>): {
+import type { ProTableProps, ProTableRowSelection } from '../types/TableTypings';
+export declare function useRowSelection(rowKey: Ref<ProTableProps['rowKey']>, rowSelection: Ref<ProTableRowSelection | undefined>): {
     selectedKey: Ref<(string | number)[]>;
     selectRowKey: (record: RecordType, selected: any[]) => void;
     selectAllRowKey: (selected: any[], selectedRows: any[], changeRows: any[]) => void;

package/dist/hooks/useTable.d.ts

@@ -1,11 +1,14 @@
 import type { Ref, ComputedRef } from 'vue';
 import type { ProCoreActionType, ProCoreFormType, ProTableRef } from '../types/TableTypings';
-export declare function useTable(tableRef: Ref<ProTableRef>): {
+export declare function useTable<T = any>(tableRef: Ref<ProTableRef>): {
+    dataSource: ComputedRef<T>;
+    loading: ComputedRef<boolean | undefined>;
     params: ComputedRef<Record<string, any>>;
-    loading: ComputedRef<ProCoreActionType['getLoadingStatus']>;
     reload: ProCoreActionType['reload'];
     mutate: ProCoreActionType['reSetDataList'];
-    setPage: ProCoreActionType['changePageInfo'];
+    setPageAndReload: ProCoreActionType['setPageAndReload'];
+    changeDataValue: ProCoreActionType['changeDataValue'];
+    setPagination: ProCoreActionType['setPagination'];
     changeLoading: ProCoreActionType['loadingOperation'];
     actionRef: ComputedRef<ProCoreActionType>;
     formRef: ComputedRef<ProCoreFormType>;

package/dist/hooks/useTableForm.d.ts

@@ -1,13 +1,14 @@
 import type { ComputedRef, Ref } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
-import type { ProTableProps } from '../types/TableTypings';
+import type { ProTablePagination, ProTableProps } from '../types/TableTypings';
 import type { ProSearchMap } from '../types/ColumnTypings';
 export declare function handleFormDefaultValue(data: ProSearchMap[]): any;
-export declare function useTableForm({ search, searchMap, params, columns }: {
+export declare function useTableForm({ search, searchMap, params, columns, setPagination }: {
     search: Ref<ProTableProps['search']>;
     searchMap: Ref<ProTableProps['searchMap']>;
     params: Ref<ProTableProps['params']>;
     columns: ComputedRef<ProTableProps['columns']>;
+    setPagination: (info: Partial<ProTablePagination>) => void;
 }): {
     formDataRef: Ref<ProSearchMap<"text">[]>;
     formParamsRef: RecordType;

package/dist/hooks/useTableScroll.d.ts

@@ -13,16 +13,16 @@ type ConfigScroll = {
 type useTableScrollType = {
     columns: ComputedRef<ProColumnsType>;
     innerWidth: Ref<number>;
-    screensRef: Ref<Partial<Record<Breakpoint, boolean>>>;
+    screens: Ref<Partial<Record<Breakpoint, boolean>>>;
 } & ConfigScroll;
 export declare function useConfigScroll(props: ProTableProps): ConfigScroll;
-export declare function useTableScroll({ scroll, columns, autoScroll, modalScroll, neverScroll, rowSelection, screensRef, innerWidth, scrollBreakpoint, }: useTableScrollType): {
+export declare function useTableScroll({ scroll, columns, autoScroll, modalScroll, neverScroll, rowSelection, screens, innerWidth, scrollBreakpoint }: useTableScrollType): {
     getScrollRef: ComputedRef<({
         x?: string | number | true | undefined;
         y?: string | number | undefined;
     } & {
         scrollToFirstRowOnChange?: boolean | undefined;
     }) | undefined>;
-    breakpoint: ComputedRef<boolean>;
+    breakpoint: ComputedRef<boolean | undefined>;
 };
 export {};

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { useTable } from './hooks/useTable';
 export { proTableProps } from './props';
 export { default } from './ProTable';
 export type { ProTableProps } from './types/TableTypings';
-export type { RequsetFunction, ProTableRef, ProCoreActionType, ProTabelFeachParams, ProCoreFormType } from './types/TableTypings';
+export type { RequsetFunction, ProTableRef, ProCoreActionType, ProTabelFeachParams, ProCoreFormType, OptionConfig, SearchConfig } from './types/TableTypings';
 export type { ProColumnType, ProColumnsType, ProSearchMap } from './types/ColumnTypings';
 export { useTable };
 export { default as GProTable } from './ProTable';