@gx-design-vue/pro-table 0.0.1

package/dist/context/TableContext.d.ts

@@ -0,0 +1,25 @@
+import type { Ref, ComputedRef } from 'vue';
+import type { InjectionKey, Slots } from 'vue';
+import type { ProColumns } from '../types/column';
+import type { ColumnsState, SettingsAction } from '../hooks/useColumnSetting';
+import type { SizeType, PaginationProps } from '../../../_utils';
+export declare type ContextType = any;
+export interface TableContextProps {
+    columns?: ComputedRef<ProColumns>;
+    cacheColumns?: ComputedRef<ProColumns>;
+    tableSize?: Ref<SizeType>;
+    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>;

package/dist/design/config.less

@@ -0,0 +1,7 @@
+@root-entry-name: default;
+
+@import 'ant-design-vue/es/style/themes/default.less';
+@import 'ant-design-vue/es/style/core/index.less';
+
+@gx-prefix: gx;
+@gx-prefix-pro: ~'@{gx-prefix}-pro';

package/dist/hooks/core/index.d.ts

@@ -0,0 +1,3 @@
+import useMemo from './useMemo';
+export * from './useTimeout';
+export { useMemo };

package/dist/hooks/core/useMemo.d.ts

@@ -0,0 +1,10 @@
+import type { ComputedRef, WritableComputedRef } from 'vue';
+declare type MemoGetter<T> = () => T;
+declare type MemoSetter<T> = (v: T) => void;
+interface WritableMemoOptions<T> {
+    get: MemoGetter<T>;
+    set: MemoSetter<T>;
+}
+declare function useMemo<T>(getter: MemoGetter<T>): ComputedRef<T>;
+declare function useMemo<T>(options: WritableMemoOptions<T>): WritableComputedRef<T>;
+export default useMemo;

package/dist/hooks/core/useTimeout.d.ts

@@ -0,0 +1,11 @@
+export declare function tryOnUnmounted(fn: Fn): void;
+export declare function useTimeoutFn(handle: Fn<any>, wait: number, native?: boolean): {
+    readyRef: import("vue").Ref<boolean>;
+    stop: () => void;
+    start: () => void;
+};
+export declare function useTimeoutRef(wait: number): {
+    readyRef: import("vue").Ref<boolean>;
+    stop: () => void;
+    start: () => void;
+};

package/dist/hooks/useColumnSetting.d.ts

@@ -0,0 +1,30 @@
+import type { Ref } from 'vue';
+import type { ProColumns } from '../types/column';
+export declare type SettingsOperationType = 'fixed' | 'drop' | 'show' | undefined;
+export declare type ColumnsState = {
+    show?: boolean;
+    fixed?: 'right' | 'left' | boolean | undefined;
+    order?: number;
+    disable?: boolean | {
+        checkbox: boolean;
+        icon: boolean;
+    };
+};
+export declare type SettingsAction = {
+    autoScroll?: Ref<boolean>;
+    sortKeyColumns: Ref<string[]>;
+    columnsMap: Record<string, ColumnsState>;
+    operationType: Ref<SettingsOperationType>;
+    setSortKeyColumns: (value: string[]) => void;
+    cacheColumnsMap: Record<string, ColumnsState>;
+    setColumnsMap: (value: Record<string, ColumnsState>, key?: SettingsOperationType) => void;
+};
+export declare type ColumnsStateType = {
+    value?: Record<string, ColumnsState>;
+    onChange?: (map: Record<string, ColumnsState>) => void;
+};
+export declare function useColumnSetting({ columns, columnsState, changeColumns }: {
+    columns: Ref<ProColumns>;
+    columnsState: Ref<ColumnsStateType | undefined>;
+    changeColumns?: (map: Record<string, ColumnsState>, fixed: boolean) => void;
+}): SettingsAction;

package/dist/hooks/useColums.d.ts

@@ -0,0 +1,24 @@
+import type { Ref, ComputedRef } from 'vue';
+import type { ColumnsState } from './useColumnSetting';
+import type { ProTableProps } from '../ProTable';
+import type { ProColumn, ProColumns } from '../types/column';
+export declare type ConfigColumns = {
+    draggabled: ComputedRef<ProTableProps['draggabled']>;
+    neverScroll: ComputedRef<ProTableProps['neverScroll']>;
+    autoScroll: ComputedRef<ProTableProps['autoScroll']>;
+};
+declare type UseColumnsType = {
+    scroll: ComputedRef<ProTableProps['scroll']>;
+    breakpoint: ComputedRef<boolean>;
+    columns: ComputedRef<ProColumns>;
+} & ConfigColumns;
+export declare function useConfigColumns(props: ProTableProps): ConfigColumns;
+export declare function useColumns({ scroll, columns, breakpoint, draggabled, autoScroll, neverScroll }: UseColumnsType): {
+    breakpoint: ComputedRef<boolean>;
+    getProColumns: ComputedRef<ProColumn[]>;
+    cacheProColumns: Ref<ProColumns>;
+    setColumns: (columnList: ProColumns) => void;
+    changeColumns: (columnState: Record<string, ColumnsState>) => void;
+    resizeColumnWidth: (w: number, col: any) => void;
+};
+export {};

package/dist/hooks/useDebounceFn.d.ts

@@ -0,0 +1,10 @@
+import type { ProTabelFeachParams } from '../types/table';
+export declare type ReturnValue<T extends any[]> = {
+    run: (...args: T) => void;
+    cancel: () => void;
+};
+declare function useDebounceFn<T extends any[]>(fn: (...args: T) => Promise<any>, wait?: number): {
+    cancel: () => void;
+    run: (...args: ProTabelFeachParams[]) => Promise<void>;
+};
+export default useDebounceFn;

package/dist/hooks/useFetchData.d.ts

@@ -0,0 +1,37 @@
+import type { ComputedRef } from 'vue';
+import type { SpinProps } from '../_utils';
+import type { ProTableProps } from '../ProTable';
+import type { ProTablePagination, ProTablePaginationConfig } from '../types/table';
+import type { ProColumns } from '../types/column';
+interface ActionType {
+    getLoading: ComputedRef<boolean | SpinProps | undefined>;
+    getPaginationInfo: ComputedRef<ProTablePagination>;
+    setPagination: (info: Partial<ProTablePagination>) => void;
+    setLoading: (loading: boolean | SpinProps) => void;
+    setColumns: (columnList: ProColumns) => void;
+    removeRowKeys: (keyList: (string | number)[]) => void;
+    columns: ComputedRef<ProColumns>;
+    formParamsRef: RecordType;
+    beforeSearchSubmit: ProTableProps['beforeSearchSubmit'];
+}
+export declare type ConfigFetchData = {
+    polling: ComputedRef<ProTableProps['polling']>;
+    request: ComputedRef<ProTableProps['request']>;
+    postData: ComputedRef<ProTableProps['postData']>;
+    waitRequest: ComputedRef<ProTableProps['waitRequest']>;
+    debounceTime: ComputedRef<ProTableProps['debounceTime']>;
+    dataSource: ComputedRef<ProTableProps['dataSource']>;
+};
+export declare function useConfigFetchData(props: ProTableProps): ConfigFetchData;
+export declare function useFetchData({ polling, request, postData, dataSource, waitRequest, debounceTime, }: ConfigFetchData, { columns, getLoading, setLoading, setColumns, removeRowKeys, formParamsRef, setPagination, getPaginationInfo, beforeSearchSubmit }: ActionType, emit: any): {
+    getDataSourceRef: ComputedRef<RecordType[]>;
+    isTreeDataRef: ComputedRef<boolean>;
+    reSetDataList: (list: RecordType[]) => void;
+    changeDataValue: ({ key, value }: {
+        key?: string | undefined;
+        value: RecordType;
+    }) => void;
+    handleTableChange: (pagination: ProTablePaginationConfig, filters: any, sorter: any) => void;
+    reload: (info?: any) => Promise<void>;
+};
+export {};

package/dist/hooks/useLoading.d.ts

@@ -0,0 +1,17 @@
+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 | {
+        prefixCls?: string | undefined;
+        spinning?: boolean | undefined;
+        size?: "small" | "default" | "large" | undefined;
+        wrapperClassName?: string | undefined;
+        tip?: string | undefined;
+        delay?: number | undefined;
+        indicator?: any;
+    }>;
+    setLoading: (loading: boolean | SpinProps) => void;
+};

package/dist/hooks/usePagination.d.ts

@@ -0,0 +1,11 @@
+import type { Ref, Slots, ComputedRef } from 'vue';
+import type { ProTableProps } from '../ProTable';
+import type { ProTablePagination } from '../types/table';
+export declare function usePagination({ slots, props, pagination }: {
+    slots: Slots;
+    props: ComputedRef<ProTableProps>;
+    pagination: Ref<ProTableProps['pagination']>;
+}): {
+    getPaginationInfo: ComputedRef<ProTablePagination>;
+    setPagination: (info: Partial<ProTablePagination>) => void;
+};

package/dist/hooks/useRowSelection.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+import type { ProTableProps } from '../ProTable';
+export declare function useRowSelection(rowKey: Ref<ProTableProps['rowKey']>, rowSelection: Ref<ProTableProps['rowSelection']>): {
+    selectedKey: Ref<(string | number)[]>;
+    selectRowKey: (record: RecordType, selected: any[]) => void;
+    selectAllRowKey: (selected: any[], selectedRows: any[], changeRows: any[]) => void;
+    removeRowKeys: (keyList: (string | number)[]) => void;
+    changeRowKey: () => void;
+};

package/dist/hooks/useTableForm.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ProTableProps } from '../ProTable';
+import type { SearchConfig } from '../types/table';
+import type { ProSearchMap } from '../types/column';
+export declare function useTableForm({ search, searchMap, params, columns }: {
+    search: Ref<SearchConfig>;
+    searchMap: Ref<ProSearchMap[]>;
+    params: Ref<ProTableProps['params']>;
+    columns: ComputedRef<ProTableProps['columns']>;
+}): {
+    formDataRef: Ref<ProSearchMap<"text", "date">[]>;
+    formParamsRef: RecordType;
+    defaultParamsRef: RecordType;
+    setFormParams: (params: any) => void;
+};

package/dist/hooks/useTableScroll.d.ts

@@ -0,0 +1,27 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { ProTableProps } from '../ProTable';
+import type { ProColumns } from '../types/column';
+declare 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']>;
+};
+declare type useTableScrollType = {
+    columns: ComputedRef<ProColumns>;
+    innerWidth: Ref<number>;
+    screensRef: 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 {};

package/dist/hooks/useTableSize.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import './design/config.less';
+import './style/table.less';
+import './style.less';
+export { default as ProTable } from './ProTable';
+export { proTableProps } from './props';
+export type { ProTableProps } from './ProTable';