@gx-design-vue/pro-table 0.2.0-beta.7 → 0.2.0-beta.71

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,183 @@
-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 { ColumnType, ColumnsType, FilterValue, GetPopupContainer, RcTableProps, SortOrder, SorterResult, TableCurrentDataSource, TableLocale, TableProps, TableRowSelection } from './typings';
+import type { SpinProps } from '../spin/typings';
+import type { TooltipProps } from '../tooltip/typings';
+import type { ProTablePagination } from '../../../types/TableTypings';
+export declare const tableProps: () => {
+    prefixCls: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    columns: {
+        type: PropType<ColumnsType>;
+        default: () => never[];
+    };
+    tableLayout: {
+        type: PropType<TableProps["tableLayout"]>;
+        default: undefined;
+    };
+    rowClassName: {
+        type: PropType<TableProps["rowClassName"]>;
+        default: undefined;
+    };
+    title: {
+        type: PropType<TableProps["title"]>;
+        default: undefined;
+    };
+    footer: {
+        type: PropType<TableProps["footer"]>;
+        default: undefined;
+    };
+    id: {
+        type: PropType<TableProps["id"]>;
+        default: undefined;
+    };
+    showHeader: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    components: {
+        type: PropType<TableProps["components"]>;
+        default: undefined;
+    };
+    customRow: {
+        type: PropType<TableProps["customRow"]>;
+        default: undefined;
+    };
+    customHeaderRow: {
+        type: PropType<TableProps["customHeaderRow"]>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<TableProps["direction"]>;
+        default: undefined;
+    };
+    expandFixed: {
+        type: PropType<TableProps["expandFixed"]>;
+        default: undefined;
+    };
+    expandColumnWidth: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    expandedRowKeys: {
+        type: PropType<TableProps["expandedRowKeys"]>;
+        default: undefined;
+    };
+    defaultExpandedRowKeys: {
+        type: PropType<TableProps["defaultExpandedRowKeys"]>;
+        default: undefined;
+    };
+    expandedRowRender: {
+        type: PropType<TableProps["expandedRowRender"]>;
+        default: undefined;
+    };
+    expandRowByClick: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    expandIcon: {
+        type: PropType<TableProps["expandIcon"]>;
+        default: undefined;
+    };
+    onExpand: {
+        type: PropType<TableProps["onExpand"]>;
+        default: undefined;
+    };
+    onExpandedRowsChange: {
+        type: PropType<TableProps["onExpandedRowsChange"]>;
+        default: undefined;
+    };
+    'onUpdate:expandedRowKeys': {
+        type: PropType<TableProps["onExpandedRowsChange"]>;
+        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<TableProps["expandedRowClassName"]>;
+        default: undefined;
+    };
+    childrenColumnName: {
+        type: PropType<TableProps["childrenColumnName"]>;
+        default: undefined;
+    };
+    rowExpandable: {
+        type: PropType<TableProps["rowExpandable"]>;
+        default: undefined;
+    };
+    sticky: {
+        type: PropType<TableProps["sticky"]>;
+        default: undefined;
+    };
+    dropdownPrefixCls: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    dataSource: {
+        type: PropType<RcTableProps["data"]>;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<boolean | SpinProps>;
+        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>;
+        default: undefined;
+    };
+    getPopupContainer: {
+        type: PropType<GetPopupContainer>;
+        default: undefined;
+    };
+    scroll: {
+        type: PropType<RcTableProps["scroll"] & {
+            scrollToFirstRowOnChange?: boolean;
+        }>;
+        default: undefined;
+    };
+    sortDirections: {
+        type: PropType<SortOrder[]>;
+        default: undefined;
+    };
+    showSorterTooltip: {
+        type: PropType<boolean | TooltipProps>;
+        default: boolean;
+    };
+    transformCellText: {
+        type: PropType<TableProps["transformCellText"]>;
+        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 { ColumnType, TableProps } from 'ant-design-vue/es/table';
+import type { ColumnsType, FilterValue, GetPopupContainer, SortOrder, SorterResult, TableCurrentDataSource, TableLocale } from 'ant-design-vue/es/table/interface';
 import type { RecordType } from '@gx-design-vue/pro-utils';
-export type { TablePaginationConfig, TableRowSelection } from 'ant-design-vue/es/table/interface';
-export type { Key } from 'ant-design-vue/es/vc-table/interface';
+import type { TableProps as RcTableProps } from 'ant-design-vue/es/vc-table/Table';
+export type { TablePaginationConfig, TableRowSelection, SelectionSelectFn } from 'ant-design-vue/es/table/interface';
+export type { Key, RenderExpandIconProps, DataIndex } 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/index.d.ts

@@ -1,35 +1,35 @@
 import type { PropType } from 'vue';
-import type { SettingExtraRender } from '../../types/SlotsTypings';
+import type { DefaultRender } from '../../types/SlotsTypings';
 export type ColumnSettingProps = {
     draggable?: boolean;
     checkable?: boolean;
-    extra?: SettingExtraRender;
+    extra?: DefaultRender;
     checkedReset?: boolean;
 };
-declare const ColumnSetting: import("vue").DefineComponent<{
+declare const ColumnSetting: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     draggable: {
-        type: PropType<boolean | undefined>;
+        type: PropType<ColumnSettingProps["draggable"]>;
         default: undefined;
     };
     checkable: {
-        type: PropType<boolean | undefined>;
+        type: PropType<ColumnSettingProps["checkable"]>;
         default: undefined;
     };
-    checkedReset: PropType<boolean | undefined>;
-    extra: PropType<SettingExtraRender>;
-}, () => import("ant-design-vue/es/_util/type").VueNode, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    checkedReset: PropType<ColumnSettingProps["checkedReset"]>;
+    extra: PropType<ColumnSettingProps["extra"]>;
+}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     draggable: {
-        type: PropType<boolean | undefined>;
+        type: PropType<ColumnSettingProps["draggable"]>;
         default: undefined;
     };
     checkable: {
-        type: PropType<boolean | undefined>;
+        type: PropType<ColumnSettingProps["checkable"]>;
         default: undefined;
     };
-    checkedReset: PropType<boolean | undefined>;
-    extra: PropType<SettingExtraRender>;
-}>>, {
+    checkedReset: PropType<ColumnSettingProps["checkedReset"]>;
+    extra: PropType<ColumnSettingProps["extra"]>;
+}>> & Readonly<{}>, {
     checkable: boolean | undefined;
     draggable: boolean | undefined;
-}>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default ColumnSetting;

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,36 +1,37 @@
 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<{
+declare const ProTableForm: import("vue").DefineComponent<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: {
-        type: PropType<ProSearchMap<"text">[]>;
+        type: PropType<ProSearchMap[]>;
         default: () => never[];
     };
     loading: PropType<boolean>;
     prefixCls: PropType<string>;
     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<{
+}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "search"[], "search", import("vue").PublicProps, 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: {
-        type: PropType<ProSearchMap<"text">[]>;
+        type: PropType<ProSearchMap[]>;
         default: () => never[];
     };
     loading: PropType<boolean>;
     prefixCls: PropType<string>;
     defaultParams: PropType<RecordType>;
-}>> & {
+}>> & Readonly<{
     onSearch?: ((...args: any[]) => any) | undefined;
-}, {
-    search: import("../../types/TableTypings").SearchConfig | undefined;
-    searchMap: ProSearchMap<"text">[];
-}>;
+}>, {
+    search: SearchConfig;
+    searchMap: ProSearchMap[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 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/index.d.ts

@@ -6,57 +6,57 @@ export type ListToolBarSetting = {
     key?: string;
     onClick?: (key?: string) => void;
 };
-declare const ListToolBar: import("vue").DefineComponent<{
+declare const ListToolBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     actions: {
-        type: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
+        type: PropType<import("../..").ProTableProps["toolBarBtn"]>;
         default: () => undefined;
     };
     settings: PropType<VueNode[]>;
     titleTip: {
-        type: PropType<import("../../types/SlotsTypings").TitleTipRender>;
+        type: PropType<import("../..").ProTableProps["titleTip"]>;
         default: () => undefined;
     };
     prefixCls: StringConstructor;
     headerTitle: {
-        type: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
+        type: PropType<import("../..").ProTableProps["headerTitle"]>;
         default: () => undefined;
     };
     titleTipText: {
-        type: PropType<string | undefined>;
+        type: PropType<import("../..").ProTableProps["titleTipText"]>;
         default: string;
     };
     optionsExtra: {
-        type: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
+        type: PropType<import("../..").ProTableProps["optionsExtra"]>;
         default: () => undefined;
     };
-}, () => import("ant-design-vue/es/_util/type").VueNode, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     actions: {
-        type: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
+        type: PropType<import("../..").ProTableProps["toolBarBtn"]>;
         default: () => undefined;
     };
     settings: PropType<VueNode[]>;
     titleTip: {
-        type: PropType<import("../../types/SlotsTypings").TitleTipRender>;
+        type: PropType<import("../..").ProTableProps["titleTip"]>;
         default: () => undefined;
     };
     prefixCls: StringConstructor;
     headerTitle: {
-        type: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
+        type: PropType<import("../..").ProTableProps["headerTitle"]>;
         default: () => undefined;
     };
     titleTipText: {
-        type: PropType<string | undefined>;
+        type: PropType<import("../..").ProTableProps["titleTipText"]>;
         default: string;
     };
     optionsExtra: {
-        type: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
+        type: PropType<import("../..").ProTableProps["optionsExtra"]>;
         default: () => undefined;
     };
-}>>, {
+}>> & Readonly<{}>, {
+    headerTitle: import("../../types/SlotsTypings").DefaultRender;
+    titleTip: import("../../types/SlotsTypings").DefaultRender;
+    optionsExtra: import("../../types/SlotsTypings").DefaultRender;
     titleTipText: string | undefined;
-    titleTip: import("../../types/SlotsTypings").TitleTipRender;
-    headerTitle: import("../../types/SlotsTypings").HeaderTitleRender;
-    optionsExtra: import("../../types/SlotsTypings").OptionsExtraRender;
-    actions: import("../../types/SlotsTypings").ToolBarBtnRender;
-}>;
+    actions: import("../../types/SlotsTypings").DefaultRender;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default ListToolBar;

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").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default FullScreenIcon;

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

@@ -1,5 +1,5 @@
 import type { PropType } from 'vue';
-import type { ProTableProps, OptionConfig } from '../../types/TableTypings';
+import type { OptionConfig, ProTableProps } from '../../types/TableTypings';
 export type OptionsFunctionType = () => void;
 export type ToolBarProps = {
     headerTitle?: ProTableProps['headerTitle'];
@@ -10,21 +10,21 @@ export type ToolBarProps = {
     settingExtra?: ProTableProps['settingExtra'];
     options?: OptionConfig | boolean;
 };
-declare const ToolbarRender: import("vue").DefineComponent<{
-    options: PropType<boolean | OptionConfig | undefined>;
-    titleTip: PropType<import("../../types/SlotsTypings").TitleTipRender>;
-    settingExtra: PropType<import("../../types/SlotsTypings").SettingExtraRender>;
-    optionsExtra: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
-    titleTipText: PropType<string | undefined>;
-    toolBarBtn: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
-    headerTitle: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    options: PropType<boolean | OptionConfig | undefined>;
-    titleTip: PropType<import("../../types/SlotsTypings").TitleTipRender>;
-    settingExtra: PropType<import("../../types/SlotsTypings").SettingExtraRender>;
-    optionsExtra: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
-    titleTipText: PropType<string | undefined>;
-    toolBarBtn: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
-    headerTitle: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
-}>>, {}>;
+declare const ToolbarRender: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    options: PropType<ProTableProps["options"]>;
+    titleTip: PropType<ProTableProps["titleTip"]>;
+    settingExtra: PropType<ProTableProps["settingExtra"]>;
+    optionsExtra: PropType<ProTableProps["optionsExtra"]>;
+    titleTipText: PropType<ProTableProps["titleTipText"]>;
+    toolBarBtn: PropType<ProTableProps["toolBarBtn"]>;
+    headerTitle: PropType<ProTableProps["headerTitle"]>;
+}>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    options: PropType<ProTableProps["options"]>;
+    titleTip: PropType<ProTableProps["titleTip"]>;
+    settingExtra: PropType<ProTableProps["settingExtra"]>;
+    optionsExtra: PropType<ProTableProps["optionsExtra"]>;
+    titleTipText: PropType<ProTableProps["titleTipText"]>;
+    toolBarBtn: PropType<ProTableProps["toolBarBtn"]>;
+    headerTitle: PropType<ProTableProps["headerTitle"]>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default ToolbarRender;

package/dist/context/TableContext.d.ts

@@ -1,15 +1,15 @@
-import type { Ref, ComputedRef } from 'vue';
-import type { InjectionKey, Slots } from 'vue';
+import type { ComputedRef, Ref } from 'vue';
 import type { SizeType } from '@gx-design-vue/pro-utils';
 import type { ProColumnsType } from '../types/ColumnTypings';
+import type { Slots } from '../types/SlotsTypings';
 import type { ColumnsState, SettingsAction } from '../hooks/useColumnSetting';
 import type { PaginationProps } from '../_utils';
-export type ContextType = any;
-export interface TableContextProps {
-    columns?: ComputedRef<ProColumnsType>;
-    cacheColumns?: ComputedRef<ProColumnsType>;
-    tableSize?: Ref<SizeType>;
-    action?: {
+export interface ProTableContextProps {
+    columns: ComputedRef<ProColumnsType>;
+    isMobile: ComputedRef<boolean>;
+    cacheColumns: ComputedRef<ProColumnsType>;
+    tableSize: Ref<SizeType>;
+    action: {
         /** @name 刷新 */
         reload: (info?: any) => void;
         toggle: () => Promise<void>;
@@ -21,6 +21,5 @@ 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>;
+declare const provideTableContext: (value: ProTableContextProps) => void, useTableContext: (injectDefaultValue?: ProTableContextProps | undefined) => ProTableContextProps;
+export { provideTableContext, useTableContext, };

package/dist/hooks/useColums.d.ts

@@ -1,4 +1,4 @@
-import type { Ref, ComputedRef } from 'vue';
+import type { ComputedRef, Ref } from 'vue';
 import type { ColumnsState } from './useColumnSetting';
 import type { ProTableProps } from '../types/TableTypings';
 import type { ProColumnType, ProColumnsType } from '../types/ColumnTypings';
@@ -9,16 +9,29 @@ 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>;
-    getProColumns: ComputedRef<ProColumnType<import("../typing").DefaultRecordType>[]>;
-    cacheProColumns: Ref<ProColumnsType<import("../typing").DefaultRecordType>>;
-    setColumns: (columnList: ProColumnsType<import("../typing").DefaultRecordType>) => void;
+    breakpoint: ComputedRef<boolean | undefined>;
+    getProColumns: ComputedRef<(import("@gx-design-vue/pro-utils/dist").DefaultProColumn & Omit<import("ant-design-vue/es/table/interface").ColumnType<import("../typing").DefaultRecordType>, "key" | "dataIndex" | "width"> & {
+        children?: ProColumnsType<import("../typing").DefaultRecordType, import("@gx-design-vue/pro-utils/dist").RecordType> | undefined;
+        uuid?: string | number;
+        index?: number;
+        show?: boolean;
+        key?: string | undefined;
+        dataIndex?: string | undefined;
+        order?: number;
+        hideInSetting?: boolean;
+        searchConfig?: import("../types/ColumnTypings").ProSearchMap<undefined, string> | undefined;
+        copyable?: boolean;
+        columnEmptyText?: string;
+        valueType?: import("../types/ColumnTypings").ProColumnsValueType;
+    })[]>;
+    cacheProColumns: Ref<ProColumnsType, ProColumnsType>;
+    setColumns: (columnList: ProColumnsType) => void;
     changeColumns: (columnState: Record<string, ColumnsState>) => void;
-    resizeColumnWidth: (w: number, col: ProColumnType) => void;
+    resizeColumnWidth: (width: number, col: ProColumnType) => void;
 };
 export {};

package/dist/hooks/useFetchData.d.ts

@@ -1,38 +1,40 @@
 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 { FilterValue, SorterResult, TableCurrentDataSource } from '../_utils/ant-design-vue/table/typings';
+import type { ProTabelFeachParams, ProTablePagination, ProTablePaginationConfig, ProTableProps } from '../types/TableTypings';
 import type { ProColumnsType } from '../types/ColumnTypings';
 interface ActionType {
-    getLoading: ComputedRef<boolean | SpinProps | undefined>;
-    getPaginationInfo: ComputedRef<ProTablePagination>;
+    loading: ComputedRef<boolean | undefined>;
+    paginationInfo: Ref<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']>;
-    request: ComputedRef<ProTableProps['request']>;
-    postData: ComputedRef<ProTableProps['postData']>;
+    request: ProTableProps['request'];
+    postData: ProTableProps['postData'];
     waitRequest: Ref<ProTableProps['waitRequest']>;
     debounceTime: ComputedRef<ProTableProps['debounceTime']>;
     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): {
-    getDataSourceRef: ComputedRef<RecordType[]>;
+export declare function useFetchData({ polling, request, postData, dataSource, waitRequest, debounceTime }: ConfigFetchData, { columns, loading, setLoading, setColumns, removeRowKeys, syncSelectedRows, formParamsRef, setPagination, paginationInfo, onBeforeSearchSubmit, hasCustomRender }: ActionType, emit: any): {
+    dataSource: ComputedRef<RecordType[]>;
     isTreeDataRef: ComputedRef<boolean>;
     reSetDataList: (list: RecordType[]) => void;
-    changeDataValue: ({ key, params }: {
-        key?: string | undefined;
-        params: RecordType;
+    changeDataValue: <T = RecordType>({ key, record, type }: {
+        record: T;
+        type: "update" | "push" | "delete" | "unshift";
+        key?: keyof T;
     }) => 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 {};