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

package/dist/hooks/useFetchData.d.ts

@@ -1,38 +1,45 @@
-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 { ComputedRef, Reactive, Ref } from 'vue';
+import type { FilterValue, SorterResult, TableCurrentDataSource } from '../_utils';
 import type { ProColumnsType } from '../types/ColumnTypings';
+import type { PageState, ProTableFetchParams, ProTablePagination, ProTablePaginationConfig, ProTableProps } from '../types/TableTypings';
 interface ActionType {
-    getLoading: ComputedRef<boolean | undefined>;
-    getPaginationInfo: ComputedRef<ProTablePagination>;
+    loading: Ref<boolean>;
+    pageInfo: Reactive<PageState>;
     setPagination: (info: Partial<ProTablePagination>) => void;
     setLoading: (loading: boolean) => void;
     setColumns: (columnList: ProColumnsType) => void;
     removeRowKeys: (keyList: (string | number)[]) => void;
     syncSelectedRows: (dataList: any[]) => void;
     columns: ComputedRef<ProColumnsType>;
-    formParamsRef: RecordType;
+    defaultFormSearch: Ref<RecordType>;
+    params: Ref<ProTableProps['params']>;
+    onRequestError: ProTableProps['onRequestError'];
     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']>;
-};
+    autoRequest: ComputedRef<ProTableProps['autoRequest']>;
+}
 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, autoRequest, polling, request, postData, dataSource, waitRequest, debounceTime }: ConfigFetchData, { params, columns, setLoading, setColumns, removeRowKeys, syncSelectedRows, defaultFormSearch, setPagination, pageInfo, onRequestError, onBeforeSearchSubmit, hasCustomRender }: ActionType, emit: any): {
+    dataSource: ComputedRef<any[]>;
     isTreeDataRef: ComputedRef<boolean>;
-    reSetDataList: (list: RecordType[]) => void;
-    changeDataValue: ({ key, params }: {
+    setTableDataList: (list: RecordType[]) => void;
+    operateTableDataRow: ({ key, type, row, value }: {
+        row?: 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;
+    run: (info?: ProTableFetchParams) => Promise<void>;
 };
 export {};

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/useScrollArea.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { TableScroll } from '../types/TableTypings';
+export declare function useScrollArea({ fitPage, hashId, scroll, baseClassName }: {
+    baseClassName: string;
+    hashId: Ref<string>;
+    scroll: ComputedRef<TableScroll>;
+    fitPage: Ref<boolean | undefined>;
+}): {
+    barRef: Ref<any, any>;
+    tableCardEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tableScrollEl: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tableOverHidden: ComputedRef<boolean>;
+    tableScrollYHeight: ComputedRef<number>;
+    tableListToolsHeight: Ref<number, number>;
+};

package/dist/hooks/useTable.d.ts

@@ -1,12 +1,58 @@
-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> {
+    /** @name loading 状态，可以直接进行修改 */
+    loading: Ref<boolean>;
+    /** @name 只读表格数据，不能修改 */
+    dataSource: ComputedRef<T[]>;
+    /** @name 表格列选择keys，只读 */
+    selectedKeys: ProCoreActionType<T, R>['selectedKeys'];
+    /** @name 表格列选择rows，只读 */
+    selectedItems: ProCoreActionType<T, R>['selectedItems'];
+    /** @name 表格列选项操作 */
+    rowsSelection: ProCoreActionType<T, R>['rowsSelection'];
+    /** @name 表格请求参数 */
+    requestSearch: ComputedRef<RequestConfig<R>['params']>;
+    /** @name 主动刷新，按照当前的参数在当前页重新请求下 */
+    reload: ProCoreActionType<T, R>['reload'];
+    /** @name 更新表格数据，直接替换，谨慎操作 */
+    setTableDataList: ProCoreActionType<T, R>['setTableDataList'];
+    /** @name 更新TableData属性值 */
+    operateTableDataRow: ProCoreActionType<T, R>['operateTableDataRow'];
+    /** @name 设置翻页、排序、筛选、并且刷新(reload) */
+    setPageInfo: ProCoreActionType<T, R>['setPageInfo'];
+    /** @name 设置翻页 */
+    setPagination: ProCoreActionType<T, R>['setPagination'];
+    /** @name 刷新并清空表单，重置为第一页 */
+    reloadAndReset: ProCoreActionType<T, R>['reloadAndReset'];
+    /** @name 改变loading状态 */
+    setLoading: ProCoreActionType<T, R>['setLoading'];
+    /** @name action表格实例 */
+    actionRef: ComputedRef<ProCoreActionType<T, R>>;
+    /** @name form查询表单实例 */
+    formRef: ComputedRef<ProCoreFormType<R>>;
+    /** @name 表格参数，用于传递给ProTable组件使用，可以对其进行修改 */
+    tableState: Reactive<ProTableState<T, R>>;
+    /** @name 更新表格参数 SearchMap，key为SearchMap唯一字段，value是更新的参数，会merge */
+    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,78 @@
-import type { ComputedRef, Ref } from 'vue';
 import type { RecordType } from '@gx-design-vue/pro-utils';
+import type { ComputedRef, Ref } from 'vue';
+import type { ProFieldValueType, ProSearchMap } from '../types/ColumnTypings';
 import type { 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 }: {
-    search: Ref<ProTableProps['search']>;
+export declare function handleFormDefaultValue(data: ProSearchMap[]): RecordType;
+export declare function useTableForm({ searchMap, columns }: {
     searchMap: Ref<ProTableProps['searchMap']>;
-    params: Ref<ProTableProps['params']>;
     columns: ComputedRef<ProTableProps['columns']>;
 }): {
-    formDataRef: Ref<ProSearchMap<"text">[]>;
-    formParamsRef: RecordType;
-    defaultParamsRef: RecordType;
-    setFormParams: (params: any) => void;
+    formCols: Ref<{
+        name: string;
+        order?: number | undefined;
+        valueType?: ProFieldValueType | undefined;
+        valueFormat?: import("../types/ColumnTypings").ProFieldValueFormat | undefined;
+        placeholder?: string | string[] | undefined;
+        allowClear?: boolean | undefined;
+        showSearch?: boolean | undefined;
+        showToday?: boolean | undefined;
+        rangeStartName?: string | undefined;
+        rangeEndName?: string | undefined;
+        use12Hours?: boolean | undefined;
+        loading?: boolean | undefined;
+        showTime?: (RecordType | boolean) | undefined;
+        initialValue?: any;
+        valueKey?: string | undefined;
+        request?: {
+            fetch?: (() => Promise<import("../types/ColumnTypings").ProSchemaValueEnumType[]>) | undefined;
+            manual?: boolean | undefined;
+            debounceTime?: number | undefined;
+        } | undefined;
+        label?: string | undefined;
+        labelWidth?: string | number | undefined;
+        labelAlign?: "center" | "left" | "right" | undefined;
+        field?: {
+            [x: string]: any;
+            rules?: RegExp | undefined;
+        } | undefined;
+        valueEnum?: {
+            label: any;
+            value: any;
+            disabled?: boolean | undefined;
+        }[] | undefined;
+    }[], ProSearchMap<"text", string>[] | {
+        name: string;
+        order?: number | undefined;
+        valueType?: ProFieldValueType | undefined;
+        valueFormat?: import("../types/ColumnTypings").ProFieldValueFormat | undefined;
+        placeholder?: string | string[] | undefined;
+        allowClear?: boolean | undefined;
+        showSearch?: boolean | undefined;
+        showToday?: boolean | undefined;
+        rangeStartName?: string | undefined;
+        rangeEndName?: string | undefined;
+        use12Hours?: boolean | undefined;
+        loading?: boolean | undefined;
+        showTime?: (RecordType | boolean) | undefined;
+        initialValue?: any;
+        valueKey?: string | undefined;
+        request?: {
+            fetch?: (() => Promise<import("../types/ColumnTypings").ProSchemaValueEnumType[]>) | undefined;
+            manual?: boolean | undefined;
+            debounceTime?: number | undefined;
+        } | undefined;
+        label?: string | undefined;
+        labelWidth?: string | number | undefined;
+        labelAlign?: "center" | "left" | "right" | undefined;
+        field?: {
+            [x: string]: any;
+            rules?: RegExp | undefined;
+        } | undefined;
+        valueEnum?: {
+            label: any;
+            value: any;
+            disabled?: boolean | undefined;
+        }[] | undefined;
+    }[]>;
+    defaultFormSearch: Ref<RecordType, RecordType>;
 };

package/dist/hooks/useTableScroll.d.ts

@@ -1,28 +1,22 @@
+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, TableScroll } 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;
-    } & {
-        scrollToFirstRowOnChange?: boolean | undefined;
-    }) | undefined>;
-    breakpoint: ComputedRef<boolean>;
+export declare function useTableScroll({ scroll, columns, autoScroll, modalScroll, neverScroll, rowSelection, screens, innerWidth, scrollBreakpoint }: useTableScrollType): {
+    proScroll: ComputedRef<TableScroll>;
+    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 { FormConfig, OptionConfig, ProCoreActionType, ProCoreFormType, ProTableFetchParams, ProTableRef, RequestFunction } from './types/TableTypings';