@gx-design-vue/pro-table 0.2.0-beta.14 → 0.2.0-beta.141

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

@@ -1,4 +1,6 @@
-export * from './spin/typings';
+export * from './input/typings';
 export * from './pagination/typings';
-export * from './table/typings';
+export * from './spin/typings';
 export * from './table/props';
+export * from './table/typings';
+export * from './tooltip/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/table/props.d.ts

@@ -1,2 +1,37 @@
-import { tableProps } from 'ant-design-vue/es/table';
-export { tableProps };
+import type { PropType } from 'vue';
+import type { SpinProps } from '../spin/typings';
+import type { RcTableProps, TableProps } from './typings';
+declare const omitProps: (keyof TableProps)[];
+export type AntTableProps = Omit<TableProps, typeof omitProps[number]>;
+export declare const tableProps: {
+    direction: {
+        type: PropType<"rtl" | "ltr">;
+        default: string;
+    };
+    transformCellText: PropType<TableProps["transformCellText"]>;
+    /**
+     * @Author      gx12358
+     * @DateTime    2022/2/8
+     * @lastTime    2022/2/8
+     * @description 是否展示外边框和列边框
+     */
+    bordered: {
+        type: PropType<TableProps["bordered"]>;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<boolean | SpinProps>;
+        default: undefined;
+    };
+    scroll: {
+        type: PropType<RcTableProps["scroll"] & {
+            scrollToFirstRowOnChange?: boolean;
+        }>;
+        default: undefined;
+    };
+    'onUpdate:expandedRowKeys': {
+        type: import("vue").PropType<(expandedKeys: import("ant-design-vue/es/vc-table/interface").Key[]) => void>;
+        default: (expandedKeys: import("ant-design-vue/es/vc-table/interface").Key[]) => void;
+    };
+};
+export {};

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 { 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 { ColumnType, TableProps } from 'ant-design-vue/es/table';
+import type { ColumnsType, FilterValue, GetPopupContainer, SorterResult, SortOrder, TableCurrentDataSource, TableLocale } from 'ant-design-vue/es/table/interface';
+import type { TableProps as RcTableProps } from 'ant-design-vue/es/vc-table/Table';
+export type { SelectionSelectFn, TablePaginationConfig, TableRowSelection } from 'ant-design-vue/es/table/interface';
+export type { AlignType, DataIndex, Key, RenderExpandIconProps } 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 { ColumnsType, ColumnType, FilterValue, GetPopupContainer, RcTableProps, SorterResult, SortOrder, TableCurrentDataSource, TableLocale, TableProps };

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,3 +1,3 @@
+export * from './ant-design-vue';
 export { initDefaultProps } from 'ant-design-vue/es/_util/props-util';
 export { noteOnce, warning } from 'ant-design-vue/es/vc-util/warning';
-export * from './ant-design-vue';

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

@@ -0,0 +1,39 @@
+import type { PropType } from 'vue';
+import type { ProSchemaValueEnumType } from '../../../types/ColumnTypings';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fetch: PropType<() => Promise<ProSchemaValueEnumType[]>>;
+    loading: PropType<boolean>;
+    debounceTime: PropType<number>;
+    manual: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    fieldName: {
+        type: PropType<string>;
+        default: string;
+    };
+    notFoundContent: {
+        type: PropType<(loading: boolean) => any>;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fetch: PropType<() => Promise<ProSchemaValueEnumType[]>>;
+    loading: PropType<boolean>;
+    debounceTime: PropType<number>;
+    manual: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    fieldName: {
+        type: PropType<string>;
+        default: string;
+    };
+    notFoundContent: {
+        type: PropType<(loading: boolean) => any>;
+    };
+}>> & Readonly<{}>, {
+    manual: boolean;
+    fieldName: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Form/{useForm.d.ts → hooks/useForm.d.ts}

@@ -1,6 +1,6 @@
 import type { RecordType } from '@gx-design-vue/pro-utils';
-import type { ProSearchMap } from '../../types/ColumnTypings';
-export declare function useForm(defaultParams: RecordType, searchMap: ProSearchMap[]): {
+import type { ProSearchMap } from '../../../types/ColumnTypings';
+export declare function useForm(defaultState: RecordType, searchMap: ProSearchMap[]): {
     formState: any;
     resetFormState: () => void;
     changeFormState: (key: string, value: any) => void;

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

@@ -1,36 +1,27 @@
-import type { PropType } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
+import type { DefineComponent, ExtractPropTypes, PropType } from 'vue';
 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;
-    };
-    modal: PropType<boolean | undefined>;
-    searchMap: {
-        type: PropType<ProSearchMap<"text">[]>;
+declare const tableForm: {
+    modalScroll: PropType<boolean | undefined>;
+    formCols: {
+        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<{
-    search: {
-        type: PropType<import("../../types/TableTypings").SearchConfig | undefined>;
-        default: () => import("../../types/TableTypings").SearchConfig;
+    loading: {
+        type: PropType<boolean | import("ant-design-vue").SpinProps>;
+        default: undefined;
     };
-    modal: PropType<boolean | undefined>;
-    searchMap: {
-        type: PropType<ProSearchMap<"text">[]>;
-        default: () => never[];
+    cardBordered: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["showIndex"]>;
+        default: boolean;
     };
-    loading: PropType<boolean>;
     prefixCls: PropType<string>;
-    defaultParams: PropType<RecordType>;
-}>> & {
-    onSearch?: ((...args: any[]) => any) | undefined;
-}, {
-    search: import("../../types/TableTypings").SearchConfig | undefined;
-    searchMap: ProSearchMap<"text">[];
-}>;
+    defaultFormSearch: {
+        type: PropType<RecordType>;
+        default: () => {};
+    };
+    onSearch: PropType<(formState: any, buttonActions?: "reset" | "submit") => any>;
+};
+export type ProTableFormProps = ExtractPropTypes<typeof tableForm>;
+declare const ProTableForm: DefineComponent<ProTableFormProps>;
 export default ProTableForm;

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

@@ -1,3 +1,3 @@
-import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 import type { ProAliasToken } from '@gx-design-vue/pro-provider';
+import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 export declare const genTableFormStyle: GenerateStyle<ProAliasToken>;

package/dist/components/Form/utils/config.d.ts

@@ -0,0 +1,5 @@
+import type { Breakpoint } from '@gx-design-vue/pro-utils';
+export declare const defaultSpans: {
+    value: Breakpoint;
+    span: number;
+}[];

package/dist/components/Form/utils/dateFormat.d.ts

@@ -0,0 +1,20 @@
+type FormatType = ((dayjs: any) => string) | string | undefined;
+/**
+ * 通过 format 来格式化日期，因为支持了function 所以需要单独的方法来处理
+ * @param  {any} endText
+ * @param  {FormatType} format
+ * @return string
+ */
+export declare function formatString(endText: any, format: FormatType): string;
+export declare function valueFormater(valueFormat?: string, showTime?: any): string;
+/**
+ * 格式化区域日期,如果是一个数组，会返回 start ~ end 数组
+ * @param  {any} value
+ * @param  {FormatType | FormatType[]} format
+ * returns string[] | Dayjs[]
+ */
+export declare const dateArrayFormatter: (value: any[], format: FormatType | FormatType[] | {
+    format: string;
+    type?: "mask";
+}, type?: "dayjs" | "string") => any | undefined;
+export {};

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

@@ -1,62 +1,55 @@
-import type { PropType } from 'vue';
 import type { VueNode } from '@gx-design-vue/pro-utils';
-export type ListToolBarSetting = {
+import type { PropType } from 'vue';
+import type { TableActionPlacement } from '../../types/TableTypings';
+export interface ListToolBarSetting {
     icon: VueNode;
     tooltip?: string;
     key?: string;
     onClick?: (key?: string) => void;
-};
-declare const ListToolBar: import("vue").DefineComponent<{
-    actions: {
-        type: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
-        default: () => undefined;
-    };
+}
+declare const ListToolBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    actions: PropType<VueNode[]>;
     settings: PropType<VueNode[]>;
-    titleTip: {
-        type: PropType<import("../../types/SlotsTypings").TitleTipRender>;
-        default: () => undefined;
-    };
     prefixCls: StringConstructor;
     headerTitle: {
-        type: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
+        type: PropType<import("../../types/TableTypings").ProTableProps["headerTitle"]>;
         default: () => undefined;
     };
-    titleTipText: {
-        type: PropType<string | undefined>;
-        default: string;
-    };
-    optionsExtra: {
-        type: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
+    listToolAfter: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["listToolAfter"]>;
         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<{
-    actions: {
-        type: PropType<import("../../types/SlotsTypings").ToolBarBtnRender>;
+    headerTitleTip: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["headerTitleTip"]>;
         default: () => undefined;
     };
-    settings: PropType<VueNode[]>;
-    titleTip: {
-        type: PropType<import("../../types/SlotsTypings").TitleTipRender>;
-        default: () => undefined;
+    titleTipText: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["titleTipText"]>;
     };
+    actionsPlacement: PropType<TableActionPlacement>;
+}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    actions: PropType<VueNode[]>;
+    settings: PropType<VueNode[]>;
     prefixCls: StringConstructor;
     headerTitle: {
-        type: PropType<import("../../types/SlotsTypings").HeaderTitleRender>;
+        type: PropType<import("../../types/TableTypings").ProTableProps["headerTitle"]>;
         default: () => undefined;
     };
-    titleTipText: {
-        type: PropType<string | undefined>;
-        default: string;
+    listToolAfter: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["listToolAfter"]>;
+        default: () => undefined;
     };
-    optionsExtra: {
-        type: PropType<import("../../types/SlotsTypings").OptionsExtraRender>;
+    headerTitleTip: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["headerTitleTip"]>;
         default: () => undefined;
     };
-}>>, {
-    titleTipText: string | undefined;
-    titleTip: import("../../types/SlotsTypings").TitleTipRender;
-    headerTitle: import("../../types/SlotsTypings").HeaderTitleRender;
-    optionsExtra: import("../../types/SlotsTypings").OptionsExtraRender;
-    actions: import("../../types/SlotsTypings").ToolBarBtnRender;
-}>;
+    titleTipText: {
+        type: PropType<import("../../types/TableTypings").ProTableProps["titleTipText"]>;
+    };
+    actionsPlacement: PropType<TableActionPlacement>;
+}>> & Readonly<{}>, {
+    headerTitle: import("../../types/SlotsTypings").DefaultRender;
+    headerTitleTip: import("../../types/SlotsTypings").DefaultRender;
+    listToolAfter: import("../../types/SlotsTypings").DefaultRender;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default ListToolBar;

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

@@ -1,3 +1,3 @@
-import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 import type { ProAliasToken } from '@gx-design-vue/pro-provider';
+import type { GenerateStyle } from 'ant-design-vue/es/theme/internal';
 export declare const genListToolBarStyle: GenerateStyle<ProAliasToken>;

package/dist/components/ScrollBar/Bar/index.d.ts

@@ -0,0 +1,44 @@
+import type { ExtractPropTypes } from 'vue';
+import { barProps } from './props';
+export type BarProps = ExtractPropTypes<typeof barProps>;
+declare const Bar: import("vue").DefineComponent<ExtractPropTypes<{
+    always: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minSize: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    barStyle: {
+        type: import("vue").PropType<{
+            x: import("vue").CSSProperties;
+            y: import("vue").CSSProperties;
+        }>;
+        default: () => {};
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    always: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minSize: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    barStyle: {
+        type: import("vue").PropType<{
+            x: import("vue").CSSProperties;
+            y: import("vue").CSSProperties;
+        }>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    always: boolean;
+    barStyle: {
+        x: import("vue").CSSProperties;
+        y: import("vue").CSSProperties;
+    };
+    minSize: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default Bar;

package/dist/components/ScrollBar/Bar/props.d.ts

@@ -0,0 +1,21 @@
+import type { CSSProperties, PropType } from 'vue';
+export declare const barProps: {
+    always: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minSize: {
+        type: PropType<number>;
+        default: number;
+    };
+    /**
+     * @description style of bar
+     */
+    barStyle: {
+        type: PropType<{
+            x: CSSProperties;
+            y: CSSProperties;
+        }>;
+        default: () => {};
+    };
+};

package/dist/components/ScrollBar/Thumb/index.d.ts

@@ -0,0 +1,35 @@
+import type { ExtractPropTypes, CSSProperties } from 'vue';
+import { thumbProps } from './props';
+export type ThumbProps = ExtractPropTypes<typeof thumbProps>;
+declare const Thumb: import("vue").DefineComponent<ExtractPropTypes<{
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    always: BooleanConstructor;
+    barStyle: {
+        type: import("vue").PropType<CSSProperties>;
+        default: () => {};
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    always: BooleanConstructor;
+    barStyle: {
+        type: import("vue").PropType<CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    always: boolean;
+    vertical: boolean;
+    barStyle: CSSProperties;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default Thumb;

package/dist/components/ScrollBar/Thumb/props.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties, ExtractPropTypes, PropType } from 'vue';
+export declare const thumbProps: {
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    always: BooleanConstructor;
+    barStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+};
+export type ThumbProps = ExtractPropTypes<typeof thumbProps>;

package/dist/components/ScrollBar/context.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+export interface ScrollbarContext {
+    className: string;
+    hashId: Ref<string>;
+    tableHeaderHeight: Ref<number>;
+    tableScrollYHeight: Ref<number>;
+    scrollbarElement: Ref<HTMLElement | undefined>;
+    wrapElement: Ref<HTMLElement | undefined>;
+}
+declare const useScrollBarContext: (injectDefaultValue?: ScrollbarContext | undefined) => ScrollbarContext, provideScrollBarContext: (value: ScrollbarContext) => void;
+export { provideScrollBarContext, useScrollBarContext };

package/dist/components/ScrollBar/util.d.ts

@@ -0,0 +1,29 @@
+import type { CSSProperties } from 'vue';
+export declare const GAP = 4;
+export declare const BAR_MAP: {
+    readonly vertical: {
+        readonly offset: "offsetHeight";
+        readonly scroll: "scrollTop";
+        readonly scrollSize: "scrollHeight";
+        readonly size: "height";
+        readonly key: "vertical";
+        readonly axis: "Y";
+        readonly client: "clientY";
+        readonly direction: "top";
+    };
+    readonly horizontal: {
+        readonly offset: "offsetWidth";
+        readonly scroll: "scrollLeft";
+        readonly scrollSize: "scrollWidth";
+        readonly size: "width";
+        readonly key: "horizontal";
+        readonly axis: "X";
+        readonly client: "clientX";
+        readonly direction: "left";
+    };
+};
+export declare const renderThumbStyle: ({ move, size, bar, }: Pick<any, "move" | "size"> & {
+    bar: (typeof BAR_MAP)[keyof typeof BAR_MAP];
+}) => CSSProperties;
+export declare const isStringNumber: (val: string) => boolean;
+export declare function addUnit(value?: string | number, defaultUnit?: string): string | undefined;

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

@@ -1,2 +1,2 @@
-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<{}>>, {}>;
+declare const FullScreenIcon: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").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,30 +1,29 @@
-import type { PropType } from 'vue';
-import type { ProTableProps, OptionConfig } from '../../types/TableTypings';
+import type { PropType, VNode } from 'vue';
+import type { OptionConfig, ProTableProps, TableActionPlacement } from '../../types/TableTypings';
 export type OptionsFunctionType = () => void;
-export type ToolBarProps = {
+export interface ToolBarProps {
+    actionsRender?: VNode[];
     headerTitle?: ProTableProps['headerTitle'];
-    titleTip?: ProTableProps['titleTip'];
-    toolBarBtn?: ProTableProps['toolBarBtn'];
+    listToolAfter?: ProTableProps['listToolAfter'];
+    headerTitleTip?: ProTableProps['headerTitleTip'];
     titleTipText?: ProTableProps['titleTipText'];
-    optionsExtra?: ProTableProps['optionsExtra'];
-    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"]>;
+    actionsPlacement: PropType<TableActionPlacement>;
+    headerTitle: PropType<ProTableProps["headerTitle"]>;
+    listToolAfter: PropType<ProTableProps["listToolAfter"]>;
+    headerTitleTip: PropType<ProTableProps["headerTitleTip"]>;
+    titleTipText: PropType<ProTableProps["titleTipText"]>;
+    actionsRender: PropType<ToolBarProps["actionsRender"]>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    options: PropType<ProTableProps["options"]>;
+    actionsPlacement: PropType<TableActionPlacement>;
+    headerTitle: PropType<ProTableProps["headerTitle"]>;
+    listToolAfter: PropType<ProTableProps["listToolAfter"]>;
+    headerTitleTip: PropType<ProTableProps["headerTitleTip"]>;
+    titleTipText: PropType<ProTableProps["titleTipText"]>;
+    actionsRender: PropType<ToolBarProps["actionsRender"]>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default ToolbarRender;

package/dist/context/TableContext.d.ts

@@ -1,26 +1,28 @@
-import type { Ref, ComputedRef } from 'vue';
-import type { InjectionKey, Slots } from 'vue';
 import type { SizeType } from '@gx-design-vue/pro-utils';
-import type { ProColumnsType } from '../types/ColumnTypings';
-import type { ColumnsState, SettingsAction } from '../hooks/useColumnSetting';
+import type { ComputedRef, Ref } from 'vue';
 import type { PaginationProps } from '../_utils';
-export type ContextType = any;
-export interface TableContextProps {
-    columns?: ComputedRef<ProColumnsType>;
-    cacheColumns?: ComputedRef<ProColumnsType>;
-    tableSize?: Ref<SizeType>;
-    action?: {
+import type { ProColumnsType } from '../types/ColumnTypings';
+import type { FormConfig, TableClassNamesType, TableScroll, TableStylesType } from '../types/TableTypings';
+export interface ProTableContextProps {
+    columns: ComputedRef<ProColumnsType>;
+    isMobile: ComputedRef<boolean>;
+    formConfig: ComputedRef<FormConfig>;
+    formActions: ComputedRef<FormConfig['actions']>;
+    formAutoRequest: ComputedRef<boolean>;
+    cacheColumns: ComputedRef<ProColumnsType>;
+    tableSize: Ref<SizeType>;
+    tableScrollState: ComputedRef<TableScroll>;
+    screenWidth: Ref<number>;
+    styles: Ref<TableStylesType>;
+    classNames: Ref<TableClassNamesType>;
+    tableListToolsHeight: Ref<number>;
+    action: {
         /** @name 刷新 */
         reload: (info?: any) => void;
         toggle: () => Promise<void>;
         setTableSize: (size: SizeType) => void;
     };
     setPagination: (info: Partial<PaginationProps>) => void;
-    settingsAction: SettingsAction;
-    slots: Slots;
-    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/tryOnActivated.d.ts

@@ -0,0 +1,2 @@
+import type { Fn } from '@gx-design-vue/pro-utils';
+export declare function tryOnActivated(fn: Fn, sync?: boolean, target?: any): void;

package/dist/hooks/useColumns.d.ts

@@ -0,0 +1,18 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ProColumnsType, ProColumnType } from '../types/ColumnTypings';
+import type { ProTableProps } from '../types/TableTypings';
+interface UseColumnsType {
+    scroll: ComputedRef<ProTableProps['scroll']>;
+    breakpoint: ComputedRef<boolean | undefined>;
+    columns: ComputedRef<ProColumnsType>;
+    draggable: Ref<ProTableProps['draggable']>;
+    neverScroll: Ref<ProTableProps['neverScroll']>;
+    autoScroll: Ref<ProTableProps['autoScroll']>;
+}
+export declare function useColumns({ scroll, columns, breakpoint, draggable, autoScroll, neverScroll }: UseColumnsType): {
+    breakpoint: ComputedRef<boolean | undefined>;
+    proColumns: ComputedRef<ProColumnsType>;
+    setColumns: (columnList: ProColumnsType) => void;
+    resizeColumnWidth: (width: number, col: ProColumnType) => void;
+};
+export {};

package/dist/hooks/useDebounceFn.d.ts

@@ -1,6 +1,6 @@
-export type ReturnValue<T extends any[]> = {
+export interface ReturnValue<T extends any[]> {
     run: (...args: T) => void;
     cancel: () => void;
-};
+}
 declare function useDebounceFn<T extends any[]>(fn: (...args: T) => Promise<any>, wait?: number): ReturnValue<T>;
 export default useDebounceFn;