@gx-design-vue/pro-table 0.2.0-beta.13 → 0.2.0-beta.131

package/dist/hooks/useLoading.d.ts

@@ -1,9 +1,6 @@
 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>;
-    setLoading: (loading: boolean) => void;
-};
+import type { BaseTableProps } from '../props';
+export declare function useLoading(options: {
+    loading: Ref<BaseTableProps['loading']>;
+    onChange: (value: BaseTableProps['loading']) => void;
+}): [Ref<boolean>, (value: boolean) => void];

package/dist/hooks/usePagination.d.ts

@@ -1,10 +1,11 @@
-import type { Ref, Slots, ComputedRef } from 'vue';
-import type { ProTableProps, ProTablePagination } from '../types/TableTypings';
-export declare function usePagination({ slots, props, pagination }: {
-    slots: Slots;
-    props: ComputedRef<ProTableProps>;
+import type { Ref } from 'vue';
+import type { PageItemRender } from '../types/SlotsTypings';
+import type { PageState, ProTablePagination, ProTableProps } from '../types/TableTypings';
+export declare function usePagination({ pagination, pageItemRender }: {
     pagination: Ref<ProTableProps['pagination']>;
+    pageItemRender: PageItemRender;
 }): {
-    getPaginationInfo: ComputedRef<ProTablePagination>;
+    paginationInfo: Ref<ProTablePagination | false>;
+    requestPagination: PageState;
     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,41 @@
-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 { RecordType } from '@gx-design-vue/pro-utils';
+import type { ComputedRef, MaybeRef, Reactive, 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';
+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 interface UseTableReturn<T extends object = RecordType, R extends object = RecordType> {
+    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: Reactive<ProTableState<T, R>>;
+    updateSearchMap: (key: keyof R | keyof T, value: Partial<any>) => void;
+}
+export declare function useTable<T extends object = RecordType, R extends object = RecordType>(tableRef: Ref<ProTableRef<T> | undefined>, options?: {
+    state?: MaybeRef<BaseTableState<T, R>> | Reactive<BaseTableState<T, R>> | ComputedRef<BaseTableState<T, R>>;
+    request?: RequestFunction<T, R>;
+}): UseTableReturn<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';
-export declare function handleFormDefaultValue(data: ProSearchMap[]): any;
-export declare function useTableForm({ search, searchMap, params, columns }: {
-    search: Ref<ProTableProps['search']>;
+import type { ProTablePagination, ProTableProps } from '../types/TableTypings';
+export declare function handleFormDefaultValue(data: ProSearchMap[]): RecordType;
+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">[]>;
-    formParamsRef: RecordType;
-    defaultParamsRef: RecordType;
-    setFormParams: (params: any) => void;
+    formDataRef: Ref<ProSearchMap<"text", string>[], ProSearchMap<"text", string>[]>;
+    formState: RecordType;
+    defaultState: RecordType;
+    setFormState: (params: RecordType) => void;
 };

package/dist/hooks/useTableScroll.d.ts

@@ -1,28 +1,27 @@
+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 = {
-    scroll: ComputedRef<ProTableProps['scroll']>;
-    autoScroll: ComputedRef<ProTableProps['autoScroll']>;
-    modalScroll: ComputedRef<ProTableProps['modalScroll']>;
-    neverScroll: ComputedRef<ProTableProps['neverScroll']>;
-    rowSelection: ComputedRef<ProTableProps['rowSelection']>;
-    scrollBreakpoint: ComputedRef<ProTableProps['scrollBreakpoint']>;
-};
+import type { ProTableProps } from '../types/TableTypings';
+interface ConfigScroll {
+    scroll: Ref<ProTableProps['scroll']>;
+    autoScroll: Ref<ProTableProps['autoScroll']>;
+    modalScroll: Ref<ProTableProps['modalScroll']>;
+    neverScroll: Ref<ProTableProps['neverScroll']>;
+    rowSelection: Ref<ProTableProps['rowSelection']>;
+    scrollBreakpoint: Ref<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,6 @@
-import type { Ref } from 'vue';
 import type { SizeType } from '@gx-design-vue/pro-utils';
-export declare function useTableSize({ size, emit }: {
+import type { Ref } from 'vue';
+export declare function useTableSize(options: {
     size: Ref<SizeType>;
-    emit: any;
-}): {
-    sizeRef: Ref<SizeType>;
-    setTableSize: (size: SizeType) => void;
-};
+    onChange: (value: SizeType) => void;
+}): [Ref<SizeType>, (value: SizeType) => void];

package/dist/index.d.ts

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