@gx-design-vue/pro-table 0.2.0-beta.11 → 0.2.0-beta.111

package/dist/hooks/useColumns.d.ts

@@ -0,0 +1,102 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ProColumnsType, ProColumnType } from '../types/ColumnTypings';
+import type { ProTableProps } from '../types/TableTypings';
+import type { ColumnsState } from './useColumnSetting';
+export interface ConfigColumns {
+    draggabled: ComputedRef<ProTableProps['draggabled']>;
+    neverScroll: ComputedRef<ProTableProps['neverScroll']>;
+    autoScroll: ComputedRef<ProTableProps['autoScroll']>;
+}
+type UseColumnsType = {
+    scroll: ComputedRef<ProTableProps['scroll']>;
+    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 | undefined>;
+    proColumns: ComputedRef<(import("../types/ColumnTypings").DefaultProColumnWithKeyOrDataIndex<import("@gx-design-vue/pro-utils/dist").RecordType> & Omit<import("ant-design-vue/es/table/interface").ColumnType<import("@gx-design-vue/pro-utils/dist").RecordType>, keyof import("../types/ColumnTypings").DefaultProColumn | "key" | "dataIndex"> & {
+        children?: ProColumnsType<import("@gx-design-vue/pro-utils/dist").RecordType, import("@gx-design-vue/pro-utils/dist").RecordType> | undefined;
+        index?: number;
+        copyText?: string | ((record: ProColumnType) => string);
+        tooltip?: false | (Partial<import("vue").ExtractPropTypes<{
+            title: import("vue-types").VueTypeValidableDef<any>;
+            trigger: import("vue").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: import("vue").PropType<import("ant-design-vue/es/tooltip").TooltipPlacement>;
+            color: import("vue").PropType<import("ant-design-vue/es/_util/type").LiteralUnion<import("ant-design-vue/es/_util/colors").PresetColorType>>;
+            transitionName: StringConstructor;
+            overlayStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties>;
+                default: import("vue").CSSProperties;
+            };
+            overlayInnerStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties>;
+                default: import("vue").CSSProperties;
+            };
+            overlayClassName: StringConstructor;
+            openClassName: StringConstructor;
+            prefixCls: StringConstructor;
+            mouseEnterDelay: NumberConstructor;
+            mouseLeaveDelay: NumberConstructor;
+            getPopupContainer: import("vue").PropType<(triggerNode: HTMLElement) => HTMLElement>;
+            arrowPointAtCenter: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            arrow: {
+                type: import("vue").PropType<boolean | {
+                    pointAtCenter?: boolean;
+                }>;
+                default: boolean | {
+                    pointAtCenter?: boolean;
+                };
+            };
+            autoAdjustOverflow: {
+                type: import("vue").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: import("vue").PropType<import("ant-design-vue/es/vc-trigger/interface").AlignType>;
+                default: import("ant-design-vue/es/vc-trigger/interface").AlignType;
+            };
+            builtinPlacements: {
+                type: import("vue").PropType<import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements>;
+                default: import("ant-design-vue/es/vc-trigger/interface").BuildInPlacements;
+            };
+            children: ArrayConstructor;
+            onVisibleChange: import("vue").PropType<(vis: boolean) => void>;
+            'onUpdate:visible': import("vue").PropType<(vis: boolean) => void>;
+            onOpenChange: import("vue").PropType<(vis: boolean) => void>;
+            'onUpdate:open': import("vue").PropType<(vis: boolean) => void>;
+        }>> & {
+            width?: number;
+            targetStyle?: Partial<import("vue").CSSProperties>;
+            hiddenLine?: number;
+            class?: string;
+        }) | undefined;
+        show?: boolean;
+        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: (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;

package/dist/hooks/useFetchData.d.ts

@@ -1,11 +1,12 @@
-import type { ComputedRef, Ref } from 'vue';
-import type { 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';
 import type { ProColumnsType } from '../types/ColumnTypings';
+import type { ProTableFetchParams, ProTablePagination, ProTablePaginationConfig, ProTableProps, SearchConfig } from '../types/TableTypings';
+import { ComputedRef, Ref } from 'vue';
 interface ActionType {
-    getLoading: ComputedRef<boolean | undefined>;
-    getPaginationInfo: ComputedRef<ProTablePagination>;
+    loading: ComputedRef<boolean | undefined>;
+    search: ComputedRef<SearchConfig | false>;
+    paginationInfo: Ref<ProTablePagination>;
     setPagination: (info: Partial<ProTablePagination>) => void;
     setLoading: (loading: boolean) => void;
     setColumns: (columnList: ProColumnsType) => void;
@@ -14,25 +15,29 @@ interface ActionType {
     columns: ComputedRef<ProColumnsType>;
     formParamsRef: RecordType;
     onBeforeSearchSubmit: ProTableProps['onBeforeSearchSubmit'];
+    hasCustomRender: ComputedRef<boolean>;
 }
-export type ConfigFetchData = {
+export interface ConfigFetchData {
+    rowKey: ComputedRef<ProTableProps['rowKey']>;
     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({ rowKey, polling, request, postData, dataSource, waitRequest, debounceTime }: ConfigFetchData, { search, 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 }: {
+    changeDataValue: ({ key, type, params, value }: {
+        params?: Partial<RecordType> | undefined;
         key?: string | undefined;
-        params: RecordType;
+        value?: any;
+        type?: "update" | "push" | "delete" | "unshift";
     }) => void;
-    handleTableChange: (pagination: ProTablePaginationConfig, filters: Record<string, any[] | null>, sorter: TableSorter) => void;
-    reload: (info?: ProTabelFeachParams) => Promise<void>;
+    handleTableChange: (pagination: ProTablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult | SorterResult[], extra?: TableCurrentDataSource) => void;
+    reload: (info?: ProTableFetchParams) => Promise<void>;
 };
 export {};

package/dist/hooks/useLoading.d.ts

@@ -1,9 +1,10 @@
 import type { Ref } from 'vue';
 import type { SpinProps } from '../_utils';
-export declare function useLoading({ emit, loading }: {
+export declare function useLoading({ emit, loading: propsLoading }: {
     loading: Ref<boolean | SpinProps | undefined>;
     emit: any;
 }): {
-    getLoading: import("vue").ComputedRef<boolean>;
-    setLoading: (loading: boolean) => void;
+    loadingComputed: import("vue").ComputedRef<boolean | undefined>;
+    loading: Ref<boolean | undefined, boolean | undefined>;
+    setLoading: (value: boolean) => void;
 };

package/dist/hooks/usePagination.d.ts

@@ -1,10 +1,15 @@
-import type { Ref, Slots, ComputedRef } from 'vue';
-import type { ProTableProps, ProTablePagination } from '../types/TableTypings';
+import type { ComputedRef, Ref } from 'vue';
+import type { Slots } from '../types/SlotsTypings';
+import type { ProTablePagination, ProTableProps } from '../types/TableTypings';
 export declare function usePagination({ slots, props, pagination }: {
     slots: Slots;
     props: ComputedRef<ProTableProps>;
     pagination: Ref<ProTableProps['pagination']>;
 }): {
-    getPaginationInfo: ComputedRef<ProTablePagination>;
+    paginationInfo: Ref<ProTablePagination, ProTablePagination>;
+    requestPagination: {
+        pageSize: number;
+        pageNum: number;
+    };
     setPagination: (info: Partial<ProTablePagination>) => void;
 };

package/dist/hooks/useRowSelection.d.ts

@@ -1,11 +1,14 @@
-import type { Ref } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
-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;
-    removeRowKeys: (keyList: (string | number)[]) => void;
+import type { Ref } from 'vue';
+import type { Key, SelectionSelectFn } from '../_utils';
+import type { ProTableRowSelection } from '../types/TableTypings';
+export declare function useRowSelection(rowKey: Ref<string>, rowSelection: Ref<ProTableRowSelection | undefined>): {
+    selectedKeys: Ref<Key[], Key[]>;
+    selectedItems: Ref<RecordType[], RecordType[]>;
+    selectRowKey: SelectionSelectFn<RecordType>;
+    selectAllRowKey: (selected: boolean, selectedRows: RecordType[], changeRows: RecordType[]) => void;
+    removeRowKeys: (keys: (string | number)[]) => void;
     changeRowKey: () => void;
-    syncSelectedRows: (dataList: any[]) => void;
+    syncSelectedRows: (dataList: RecordType[]) => void;
+    clearAllRowKeys: () => void;
 };

package/dist/hooks/useTable.d.ts

@@ -1,12 +1,39 @@
-import type { Ref, ComputedRef } from 'vue';
-import type { ProCoreActionType, ProCoreFormType, ProTableRef } from '../types/TableTypings';
-export declare function useTable(tableRef: Ref<ProTableRef>): {
-    params: ComputedRef<Record<string, any>>;
-    loading: ComputedRef<ProCoreActionType['getLoadingStatus']>;
-    reload: ProCoreActionType['reload'];
-    mutate: ProCoreActionType['reSetDataList'];
-    setPage: ProCoreActionType['changePageInfo'];
-    changeLoading: ProCoreActionType['loadingOperation'];
-    actionRef: ComputedRef<ProCoreActionType>;
-    formRef: ComputedRef<ProCoreFormType>;
+import type { ComputedRef, MaybeRef, Ref } from 'vue';
+import type { BaseTableProps } from '../props';
+import type { ProColumnsType, ProSearchMap } from '../types/ColumnTypings';
+import type { ProCoreActionType, ProCoreFormType, ProTableProps, ProTableRef, ProTableRowSelection, RequestConfig, RequestFunction } from '../types/TableTypings';
+import { RecordType } from '@gx-design-vue/pro-utils';
+export type ProTableState<T extends object = RecordType, R extends object = RecordType> = BaseTableProps & {
+    params: R;
+    columns: ProColumnsType<T, R>;
+    dataSource: T[];
+    rowSelection: ProTableRowSelection<T>;
+    searchMap: ProSearchMap<undefined, keyof R | keyof T>[];
+    rowKey?: keyof T;
+    postData?: (data: T[]) => any;
+    onReset?: (params?: Partial<R>) => void;
+    onReload?: (params?: Partial<R>) => void;
+    onSubmit?: (params?: Partial<R>) => void;
+};
+export type BaseTableState<T extends object = RecordType, R extends object = RecordType> = Omit<ProTableProps<T, R>, 'request'>;
+export declare function useTable<T extends object = RecordType, R extends object = RecordType>(tableRef: Ref<ProTableRef<T> | undefined>, options?: {
+    state?: MaybeRef<BaseTableState<T, R>>;
+    request?: RequestFunction<T, R>;
+}): {
+    loading: Ref<boolean>;
+    dataSource: ComputedRef<T[]>;
+    selectedKeys: ProCoreActionType<T, R>['selectedKeys'];
+    selectedItems: ProCoreActionType<T, R>['selectedItems'];
+    rowsSelection: ProCoreActionType<T, R>['rowsSelection'];
+    requestSearch: ComputedRef<RequestConfig<R>['params']>;
+    reload: ProCoreActionType<T, R>['reload'];
+    mutate: ProCoreActionType<T, R>['reSetDataList'];
+    setPageAndReload: ProCoreActionType<T, R>['setPageAndReload'];
+    setDataValue: ProCoreActionType<T, R>['setDataValue'];
+    setPagination: ProCoreActionType<T, R>['setPagination'];
+    reloadAndReset: ProCoreActionType<T, R>['reloadAndReset'];
+    setLoading: ProCoreActionType<T, R>['setLoading'];
+    actionRef: ComputedRef<Partial<ProCoreActionType<T, R>>>;
+    formRef: ComputedRef<ProCoreFormType<R>>;
+    tableState: ProTableState<T, R>;
 };

package/dist/hooks/useTableForm.d.ts

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

package/dist/hooks/useTableScroll.d.ts

@@ -1,28 +1,28 @@
+import type { Breakpoint } from '@gx-design-vue/pro-utils';
 import type { ComputedRef, Ref } from 'vue';
-import { type Breakpoint } from '@gx-design-vue/pro-utils';
-import type { ProTableProps } from '../types/TableTypings';
 import type { ProColumnsType } from '../types/ColumnTypings';
-type ConfigScroll = {
+import type { ProTableProps } from '../types/TableTypings';
+interface ConfigScroll {
     scroll: ComputedRef<ProTableProps['scroll']>;
     autoScroll: ComputedRef<ProTableProps['autoScroll']>;
     modalScroll: ComputedRef<ProTableProps['modalScroll']>;
     neverScroll: ComputedRef<ProTableProps['neverScroll']>;
     rowSelection: ComputedRef<ProTableProps['rowSelection']>;
     scrollBreakpoint: ComputedRef<ProTableProps['scrollBreakpoint']>;
-};
+}
 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): {
-    getScrollRef: ComputedRef<({
-        x?: string | number | true | undefined;
-        y?: string | number | undefined;
+export declare function useTableScroll({ scroll, columns, autoScroll, modalScroll, neverScroll, rowSelection, screens, innerWidth, scrollBreakpoint }: useTableScrollType): {
+    proScroll: ComputedRef<({
+        x?: number | true | string;
+        y?: number | string;
     } & {
-        scrollToFirstRowOnChange?: boolean | undefined;
+        scrollToFirstRowOnChange?: boolean;
     }) | undefined>;
-    breakpoint: ComputedRef<boolean>;
+    breakpoint: ComputedRef<boolean | undefined>;
 };
 export {};

package/dist/hooks/useTableSize.d.ts

@@ -1,9 +1,9 @@
-import type { Ref } from 'vue';
 import type { SizeType } from '@gx-design-vue/pro-utils';
+import type { Ref } from 'vue';
 export declare function useTableSize({ size, emit }: {
     size: Ref<SizeType>;
     emit: any;
 }): {
-    sizeRef: Ref<SizeType>;
+    sizeRef: Ref<SizeType, SizeType>;
     setTableSize: (size: SizeType) => void;
 };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { useTable } from './hooks/useTable';
+export * from './hooks/useTable';
+export type { BaseTableProps } from './props';
 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 { ProColumnType, ProColumnsType, ProSearchMap } from './types/ColumnTypings';
-export { useTable };
 export { default as GProTable } from './ProTable';
+export type { ProColumnsType, ProColumnType, ProFieldValueType, ProSearchMap } from './types/ColumnTypings';
+export type { CustomRenderResult, ProTableBodyCellProps } from './types/SlotsTypings';
+export type { PageState, ProTableProps } from './types/TableTypings';
+export type { OptionConfig, ProCoreActionType, ProCoreFormType, ProTableFetchParams, ProTableRef, RequestFunction, SearchConfig } from './types/TableTypings';