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

package/dist/types/ColumnTypings.d.ts

@@ -1,6 +1,6 @@
 import type { RecordType, VueNode } from '@gx-design-vue/pro-utils';
-import type { DefaultRecordType } from '../typing';
-import type { ColumnType } from '../_utils';
+import type { CSSProperties } from 'vue';
+import type { AlignType, ColumnType, TooltipProps } from '../_utils';
 /**
  * @param text 文本框
  * @param date 日期 YYYY-MM-DD
@@ -9,7 +9,7 @@ import type { ColumnType } from '../_utils';
  * @param time: 时间 HH:mm:ss
  * @param select 下拉选择器
  */
-export type ProFieldValueType = 'text' | 'date' | 'select' | 'treeSelect' | 'dateMonth' | 'dateRange' | 'time';
+export type ProFieldValueType = 'text' | 'number' | 'numberRange' | 'select' | 'treeSelect' | 'date' | 'dateWeek' | 'dateQuarter' | 'dateMonth' | 'dateYear' | 'dateRange' | 'time';
 /**
  * @param text 文本框
  * @param date 日期 YYYY-MM-DD
@@ -19,17 +19,18 @@ export type ProFieldValueType = 'text' | 'date' | 'select' | 'treeSelect' | 'dat
  * @param select 下拉选择器
  */
 export type ProFieldValueFormat = 'YYYY-MM-DD' | 'YYYY-MM' | 'YYYY-MM-DD HH:mm:ss' | 'HH:mm:ss';
-export type ProSchemaValueEnumType = {
+export interface ProSchemaValueEnumType {
     /** @name 演示的文案 */
-    text: VueNode | JSX.Element;
+    label: VueNode | JSX.Element;
     /** @name 演示的value值 */
     value: any;
     /** @name 是否禁用 */
     disabled?: boolean;
-};
+}
 type ProSchemaValueType<ValueType> = (ValueType | ProFieldValueType);
-export type ProSearchMap<ValueType = 'text'> = {
-    name?: string;
+export interface ProSearchMap<ValueType = 'text', ParamsKey = string> {
+    name: ParamsKey;
+    order?: number;
     /** 选择如何渲染相应的模式 */
     valueType?: ProSchemaValueType<ValueType>;
     /** valueType为date|dateMonth|dateRange|time生效 */
@@ -55,18 +56,55 @@ export type ProSearchMap<ValueType = 'text'> = {
     initialValue?: any;
     /** 针对select、treeselect取值的key */
     valueKey?: string;
-    /** 表单的属性值（ant-design）*/
-    field?: RecordType;
+    /** 远程查询数据 */
+    request?: {
+        fetch?: () => Promise<ProSchemaValueEnumType[]>;
+        manual?: boolean;
+        debounceTime?: number;
+    };
+    /** 查询表单label */
+    label?: string;
+    /** 查询表单label - 宽度 */
+    labelWidth?: string | number;
+    /** 查询表单label - 对齐方式 */
+    labelAlign?: 'center' | 'left' | 'right';
+    /** 表单的属性值（ant-design） */
+    field?: {
+        rules?: RegExp;
+        [key: string]: any;
+    };
     /**
      * 支持 object 和Map，Map 是支持其他基础类型作为 key
      *
      * @name 映射值的类型
      */
     valueEnum?: ProSchemaValueEnumType[];
+}
+export type ColumnWithKeyOrDataIndex<T = any[]> = {
+    key: keyof T | 'action' | string;
+    dataIndex?: keyof T | 'action' | string;
+} | {
+    key?: keyof T | 'action' | string;
+    dataIndex: keyof T | 'action' | string;
 };
-export type ProColumnType<RecordType = DefaultRecordType> = ColumnType<RecordType> & {
-    children?: ProColumnsType<RecordType>;
+export interface DefaultProColumn {
     uuid?: string | number;
+    align?: AlignType;
+    fixed?: boolean | 'right' | 'left';
+    width?: number | string;
+}
+export type DefaultProColumnWithKeyOrDataIndex<T = any[]> = DefaultProColumn & ColumnWithKeyOrDataIndex<T>;
+export type ProColumn<T = undefined, R = any[]> = T extends undefined ? DefaultProColumnWithKeyOrDataIndex<R> : DefaultProColumnWithKeyOrDataIndex<R> & T;
+export type ProColumnType<DataValue = RecordType, SearchParams = RecordType> = ProColumn<Omit<ColumnType<DataValue>, keyof DefaultProColumnWithKeyOrDataIndex> & {
+    children?: ProColumnsType<DataValue, SearchParams>;
+    index?: number;
+    copyText?: string | ((record: ProColumnType) => string);
+    tooltip?: false | (TooltipProps & {
+        width?: number;
+        targetStyle?: Partial<CSSProperties>;
+        hiddenLine?: number;
+        class?: string;
+    });
     /** 不在列表中显示 */
     show?: boolean;
     /** 列表顺序值 */
@@ -74,15 +112,15 @@ export type ProColumnType<RecordType = DefaultRecordType> = ColumnType<RecordTyp
     /** 不在配置工具中显示 */
     hideInSetting?: boolean;
     /** 表单搜索配置 */
-    searchConfig?: ProSearchMap;
+    searchConfig?: ProSearchMap<undefined, keyof DataValue | keyof SearchParams>;
     /** 是否拷贝 */
     copyable?: boolean;
     /** 值为空时，默认取值 */
     columnEmptyText?: string;
     valueType?: ProColumnsValueType;
-};
-export type ProColumnsType<RecordType = DefaultRecordType> = (ProColumnType<RecordType>)[];
-export type ProColumnsValueType = 'text' | 'link' | 'time' | 'dateMonth' | 'dateTime' | {
+}, DataValue>;
+export type ProColumnsType<DataValue = RecordType, SearchParams = RecordType> = ProColumnType<DataValue, SearchParams>[];
+export type ProColumnsValueType = 'text' | 'link' | 'time' | 'dateMonth' | 'dateTime' | 'date' | {
     node?: string;
     class?: string;
     attr?: string;

package/dist/types/SlotsTypings.d.ts

@@ -1,12 +1,50 @@
-import type { CustomRender, WithFalse } from '@gx-design-vue/pro-utils';
-export type HeaderTitleRender = WithFalse<CustomRender>;
-export type TitleTipRender = WithFalse<CustomRender>;
-export type ToolBarBtnRender = WithFalse<CustomRender>;
-export type OptionsExtraRender = WithFalse<CustomRender>;
-export type SettingExtraRender = WithFalse<CustomRender>;
-export type PageItemRender = WithFalse<(opt: {
+import type { CustomRender, RecordType, WithFalse } from '@gx-design-vue/pro-utils';
+import type { ColumnType, RenderExpandIconProps } from '../_utils';
+import type { ProColumnType } from '../types/ColumnTypings';
+export interface ProTableBodyCellProps<T = RecordType> {
+    text: any;
+    value: any;
+    record: T;
+    index: number;
+    column: ProColumnType<T>;
+}
+export interface AntTableSlotsType {
+    emptyText?: any;
+    expandIcon?: RenderExpandIconProps<any>;
+    title?: any;
+    footer?: any;
+    summary?: any;
+    expandedRowRender?: any;
+    expandColumnTitle?: any;
+    bodyCell?: (props: ProTableBodyCellProps<any>) => void;
+    headerCell?: (props: {
+        title: any;
+        column: ColumnType;
+    }) => void;
+    customFilterIcon?: any;
+    customFilterDropdown?: any;
+    default: any;
+}
+export type ProTableSlotsKey = 'search' | 'actions' | 'headerTitle' | 'titleTip' | 'settingExtra' | 'pageItemRender' | 'customRender';
+export declare const proTableSlotsKey: ProTableSlotsKey[];
+export type Slots = Readonly<Omit<Record<ProTableSlotsKey, () => void>, 'customRender' | 'pageItemRender'> & {
+    customRender: (params: CustomRenderResult) => void;
+    pageItemRender: (params: {
+        page: number;
+        type: 'page' | 'prev' | 'next' | 'jump-prev' | 'jump-next';
+        originalElement: any;
+    }) => void;
+}>;
+export interface CustomRenderResult<T = RecordType> {
+    currentData: T[];
+    dataSource: T[];
+}
+export type PageItemFn = (opt: {
     page: number;
     type: 'page' | 'prev' | 'next' | 'jump-prev' | 'jump-next';
     originalElement: any;
-}) => CustomRender>;
-export type CustomizeRender = WithFalse<(dataSource: any[]) => CustomRender>;
+}) => CustomRender;
+export type CustomDataFn<T = RecordType> = (params: CustomRenderResult<T>) => CustomRender;
+export type DefaultRender = WithFalse<CustomRender>;
+export type PageItemRender = WithFalse<PageItemFn>;
+export type CustomDataRender<T = RecordType> = WithFalse<CustomDataFn<T>>;

package/dist/types/TableTypings.d.ts

@@ -1,23 +1,24 @@
-import type { CSSProperties } from 'vue';
-import type { RecordType, WithFalse, CustomRender, VueNode, SizeType, Breakpoint } from '@gx-design-vue/pro-utils';
-import type { ProSearchMap, ProColumnType, ProColumnsType } from './ColumnTypings';
-import type { DefaultRecordType } from '../typing';
-import type { HeaderTitleRender, ToolBarBtnRender, CustomizeRender, TitleTipRender, OptionsExtraRender, SettingExtraRender, PageItemRender } from './SlotsTypings';
-import type { TableRowSelection, TablePaginationConfig, SpinProps, TableFilters, TableSorter, TableProps } from '../_utils';
-import type { ColumnSettingProps } from '../components/ColumnSetting';
-import type { ColumnsState, ColumnsStateType } from '../hooks/useColumnSetting';
-export type ProTabelFeachParams = {
-    params?: any;
-    filters?: TableFilters;
-    sorter?: TableSorter;
+import type { Breakpoint, CustomRender, RecordType, SizeType, WithFalse } from '@gx-design-vue/pro-utils';
+import type { ComputedRef, CSSProperties, Ref } from 'vue';
+import type { FilterValue, SelectionSelectFn, SorterResult, TableCurrentDataSource, TablePaginationConfig, TableProps, TableRowSelection, TableSorterRecord } from '../_utils';
+import type { ProColumnsType, ProColumnType, ProSearchMap } from './ColumnTypings';
+import type { CustomDataRender, DefaultRender, PageItemRender } from './SlotsTypings';
+export interface ProTableFetchParams<R = RecordType> {
+    params?: R;
+    filters?: Record<string, FilterValue | null>;
+    sorter?: SorterResult | SorterResult[];
     pagination?: ProTablePagination;
     removeKeys?: (string | number)[];
     immediate?: boolean;
     isPolling?: boolean;
-};
+    showLoading?: boolean;
+    extra?: TableCurrentDataSource;
+}
+export type TableActionPlacement = 'left' | 'right';
 export type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
 export type ProFieldEmptyText = string | false;
 export type ProTableRowSelection<T = any> = Omit<TableRowSelection<T>, 'selectedRowKeys'> & {
+    selectedRows?: T[];
     selectedRowKeys?: (string | number)[];
 };
 export interface ProTablePaginationConfig extends Omit<TablePaginationConfig, 'position'> {
@@ -25,112 +26,159 @@ export interface ProTablePaginationConfig extends Omit<TablePaginationConfig, 'p
     position?: TablePaginationPosition[];
 }
 export type ProTablePagination = ProTablePaginationConfig | false;
-export type RequestData<T = any> = {
+export interface PageState {
+    pageSize: number;
+    pageNum: number;
+}
+export interface RequestData<T = any> {
     data: T[] | undefined;
     success: boolean;
     total: number;
-} & RecordType;
-export type RequsetConfig = {
-    params: {
-        pageSize?: number;
-        pageNum?: number;
-    };
-    sort: TableSorter;
-    filter: TableFilters;
-};
-export type RequsetFunction<T = any> = (params: RequsetConfig['params'], sort: RequsetConfig['sort'], filter: RequsetConfig['filter']) => Promise<Partial<RequestData<T>>>;
+}
+export interface RequestConfig<T> {
+    params: T extends undefined ? PageState : {
+        pageSize: number;
+        pageNum: number;
+    } & Partial<T>;
+    sorter: TableSorterRecord[];
+    filter: Record<string, FilterValue | null>;
+    extra?: TableCurrentDataSource;
+}
+export type RequestFunction<T = any, D = undefined> = (props: RequestConfig<D>) => Promise<Partial<RequestData<T>> | undefined>;
 export type ColConfig = Partial<Record<Breakpoint, number>>;
-export type SearchConfig = {
-    searchText?: string;
-    resetText?: string;
+export interface SearchConfig {
     className?: string;
+    actions?: {
+        reload?: boolean;
+        reset?: boolean;
+        searchText?: string;
+        resetText?: string;
+    };
+    collapsed?: boolean;
     defaultCollapsed?: boolean;
-    showSearch?: boolean;
-    showReset?: boolean;
+    autoRequest?: boolean;
     collapseRender?: WithFalse<(collapsed?: boolean) => CustomRender>;
     span?: ColConfig;
-};
+    label?: {
+        gap?: number;
+        colon?: boolean;
+        width?: number;
+        align?: 'center' | 'left' | 'right';
+    };
+}
 export interface OptionConfig {
-    reload?: (() => VueNode | JSX.Element) | boolean;
-    density?: boolean;
-    setting?: boolean | ColumnSettingProps;
-    fullScreen?: (() => VueNode | JSX.Element) | boolean | (() => Promise<void>);
+    reload?: (() => CustomRender) | boolean;
+    fullScreen?: (() => CustomRender) | boolean | (() => Promise<void>);
 }
 /** action表格实例 */
-export interface ProCoreActionType {
-    pageParams?: RecordType | boolean;
-    getLoadingStatus?: boolean | SpinProps | undefined;
+export interface ProCoreActionType<T = RecordType, R = RecordType> {
+    /** @name loadingStatus */
+    loading: Ref<boolean>;
+    dataSource: ComputedRef<T[]>;
+    getLoadingStatus: () => boolean;
+    pagination: R | boolean;
+    pageState: PageState;
+    selectedKeys: ComputedRef<(string | number)[]>;
+    selectedItems: ComputedRef<T[]>;
+    rowsSelection?: {
+        clear: () => void;
+        sync: (data: T[]) => void;
+        remove: (keys: (string | number)[]) => void;
+        select: SelectionSelectFn<T>;
+        selectAll: TableRowSelection<T>['onSelectAll'];
+    };
     /** @name 刷新 */
-    reload?: (info?: ProTabelFeachParams) => void;
+    reload: (info?: ProTableFetchParams<R>) => void;
     /** @name 刷新并清空表单，重置为第一页 */
-    reloadAndRest?: (callBack?: () => void) => void;
-    /** @name 设置翻页、排序、筛选*/
-    changePageInfo?: (pagination: ProTablePaginationConfig, filters: any, sorter: any) => void;
+    reloadAndReset: (options?: {
+        callBack?: () => void;
+        wait?: boolean;
+    }) => void;
+    /** @name 设置翻页 */
+    setPagination: (pagination: ProTablePaginationConfig) => void;
+    /** @name 设置翻页、排序、筛选、并且reload */
+    setPageAndReload: (pagination: ProTablePaginationConfig, filters?: Record<string, FilterValue | null>, sorter?: SorterResult | SorterResult[], extra?: TableCurrentDataSource) => void;
     /** @name 更新TableData属性值 */
-    reSetDataList?: (data: RecordType[]) => void;
+    reSetDataList: (data: T[]) => void;
     /** @name 更新TableData属性值 */
-    changeDataValue?: ({ key, params }: {
-        key?: string;
-        params: RecordType;
+    setDataValue: ({ key, type, row, value }: {
+        row?: Partial<T>;
+        key?: keyof T;
+        value?: any;
+        type?: 'update' | 'push' | 'delete' | 'unshift';
     }) => void;
     /** @name 改变loading状态 */
-    loadingOperation?: (loading: boolean) => void;
+    setLoading: (loading: boolean) => void;
 }
 /** form查询表单实例 */
-export interface ProCoreFormType {
+export interface ProCoreFormType<R = RecordType> {
     /** @name 获取表格-表单请求参数 */
-    formParams?: RecordType;
+    getFormState?: () => R;
     /** @name 获取表格-内部表单参数 */
-    getFormState?: () => RecordType;
+    getFormInnerState?: () => R;
     /** @name 重置内部表单组件参数 */
-    restForm?: (callBack?: () => void) => void;
+    restFormState?: (callBack?: () => void) => void;
 }
-export interface ProTableRef {
-    formRef: () => ProCoreFormType;
-    actionRef: () => ProCoreActionType;
+export interface ProTableRef<T = RecordType, R = RecordType> {
+    formRef: () => ProCoreFormType<R>;
+    actionRef: () => ProCoreActionType<T, R>;
 }
-export type ProTableProps<RecordType extends DefaultRecordType = DefaultRecordType> = Omit<TableProps<RecordType>, 'columns'> & Partial<{
-    tableClassName: string;
-    tableStyle: CSSProperties;
-    rowKey: string;
+export type ProTableProps<DataRecord extends object = RecordType, ParamsType extends object = RecordType> = Omit<TableProps, 'columns' | 'dataSource'> & Partial<{
+    dataSource: DataRecord[];
+    tableProps: {
+        class?: string;
+        style?: CSSProperties;
+    };
+    actionProps: {
+        placement?: TableActionPlacement;
+        actions?: DefaultRender[];
+    };
+    rowKey: keyof DataRecord;
     titleTipText: string;
     autoScroll: boolean;
+    showSearch: boolean;
+    keepAliveReload: boolean;
+    emptyTextProps: {
+        class?: string;
+        style?: CSSProperties;
+        extraProps?: RecordType;
+    };
     columnEmptyText: ProFieldEmptyText;
+    showLoading: boolean;
     neverScroll: boolean;
     modalScroll: boolean;
     scrollBreakpoint: Breakpoint | number;
-    draggabled: boolean;
+    useDefaultScrollStyle: boolean;
+    draggable: boolean;
     bordered: boolean;
     showIndex: boolean;
+    cardBordered: boolean;
     virtualScroll: boolean;
     size: SizeType;
     align: ProColumnType['align'];
     options: OptionConfig | boolean;
     rowSelection: ProTableRowSelection;
-    columns: ProColumnsType<RecordType>;
-    columnsState: ColumnsStateType;
+    columns: ProColumnsType<DataRecord, ParamsType>;
     waitRequest: boolean;
     polling: number;
     debounceTime: number;
-    request: RequsetFunction<RecordType>;
-    params: Record<string, unknown>;
-    postData: (data: any[]) => any;
+    request: RequestFunction<DataRecord, ParamsType>;
+    params: ParamsType;
+    postData: (data: DataRecord[]) => DataRecord[];
     pagination: ProTablePagination;
-    search: SearchConfig;
-    searchMap: ProSearchMap[];
-    onReset: (params?: Partial<Record<string, any>>) => any;
-    onReload: (params?: Partial<Record<string, any>>) => any;
-    onSubmit: (params?: Partial<Record<string, any>>) => any;
+    search: SearchConfig | false;
+    searchMap: ProSearchMap<undefined, keyof ParamsType | keyof DataRecord>[];
+    onReset: (params?: Partial<ParamsType>) => void;
+    onReload: (params?: Partial<ParamsType>) => void;
+    onSubmit: (params?: Partial<ParamsType>) => void;
     onSizeChange: (size: string) => any;
     onLoadingChange: (loading: boolean) => any;
     onRequestError: (e: Error) => void;
-    onBeforeSearchSubmit: RequsetFunction<RecordType>;
-    onColumnsStateChange: (data: ColumnsState[]) => void;
-    titleTip: TitleTipRender;
-    headerTitle: HeaderTitleRender;
-    toolBarBtn: ToolBarBtnRender;
-    customRender: CustomizeRender;
-    optionsExtra: OptionsExtraRender;
-    settingExtra: SettingExtraRender;
+    onBeforeSearchSubmit: RequestFunction<DataRecord, ParamsType>;
+    titleTip: DefaultRender;
+    emptyText: DefaultRender;
+    headerTitle: DefaultRender;
+    customRender: CustomDataRender;
+    settingExtra: DefaultRender;
     pageItemRender: PageItemRender;
 }>;

package/dist/utils/utils.d.ts

@@ -1,2 +1,5 @@
 import type { ProColumnsValueType } from '../types/ColumnTypings';
-export declare function valueFormat(value: any, format: ProColumnsValueType | undefined, className: string): any;
+import type { ProTablePagination } from '../types/TableTypings';
+export declare function valueFormat(value: any, format: ProColumnsValueType | undefined, className: string, hashId: string): any;
+export declare function getCurrentData(data: any[], pageInfo: ProTablePagination): any[];
+export declare function handleCopy(codeStr: string): void;

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@gx-design-vue/pro-table",
-  "version": "0.2.0-beta.13",
+  "type": "module",
+  "version": "0.2.0-beta.131",
+  "description": "Gx Design Pro Table",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/pro-table.js",
+      "require": "./dist/pro-table.umd.cjs"
+    }
+  },
+  "main": "./dist/pro-table.umd.cjs",
+  "module": "./dist/pro-table.js",
+  "types": "./dist",
+  "files": [
+    "dist",
+    "volar.d.ts"
+  ],
   "scripts": {
     "dev": "vite",
     "build": "vite build",
@@ -10,61 +26,25 @@
     "typecheck": "vue-tsc --noEmit && vue-tsc --noEmit -p tsconfig.vitest.json --composite false",
     "lint": "TIMING=1 eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore"
   },
-  "files": [
-    "dist",
-    "volar.d.ts"
-  ],
-  "types": "./dist",
-  "main": "./dist/pro-table.umd.js",
-  "module": "./dist/pro-table.mjs",
-  "exports": {
-    ".": {
-      "import": "./dist/pro-table.mjs",
-      "require": "./dist/pro-table.umd.js"
-    }
+  "peerDependencies": {
+    "vxe-table": "^4.17.11",
+    "ant-design-vue": "^4.2.6",
+    "vue": ">=3.0.0"
   },
   "dependencies": {
-    "@vueuse/core": "^9.10.0",
-    "@gx-design-vue/pro-utils": "^0.2.0-beta.8",
-    "@gx-design-vue/pro-hooks": "^0.2.0-beta.9",
-    "@gx-design-vue/pro-provider": "^0.1.0-beta.16",
-    "ant-design-vue": "^4.0.0",
+    "@gx-design-vue/pro-app": "^0.1.0-beta.33",
+    "@gx-design-vue/pro-hooks": "^0.2.0-beta.60",
+    "@gx-design-vue/pro-provider": "^0.1.0-beta.133",
+    "@gx-design-vue/pro-utils": "^0.2.0-beta.84",
+    "@vueuse/core": "^14.0.0",
     "dayjs": "^1.11.0",
-    "lodash-es": "^4.17.21",
-    "vue": "^3.2.45",
-    "vue-types": "^4.1.1"
+    "lodash-es": "^4.17.21"
   },
   "devDependencies": {
-    "@rollup/plugin-typescript": "^8.3.0",
-    "@rushstack/eslint-patch": "^1.1.0",
     "@types/lodash-es": "^4.17.6",
-    "@types/jsdom": "^16.2.14",
-    "@types/node": "^16.11.26",
-    "@vitejs/plugin-vue": "^4.2.3",
-    "@vitejs/plugin-vue-jsx": "^3.0.1",
-    "@vue/eslint-config-prettier": "^7.0.0",
-    "@vue/eslint-config-typescript": "^10.0.0",
-    "@vue/tsconfig": "^0.1.3",
-    "eslint": "^8.13.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-vue": "^8.6.0",
-    "jsdom": "^19.0.0",
-    "less": "^4.1.2",
-    "postcss": "^8.4.12",
-    "postcss-html": "^1.4.1",
-    "postcss-less": "^6.0.0",
-    "prettier": "^2.6.2",
-    "rollup": "^2.70.2",
-    "stylelint": "^14.7.1",
-    "stylelint-config-prettier": "^9.0.3",
-    "stylelint-config-recommended": "^7.0.0",
-    "stylelint-config-recommended-vue": "^1.4.0",
-    "stylelint-config-standard": "^25.0.0",
-    "stylelint-order": "^5.0.0",
-    "typescript": "^4.6.4",
-    "vite": "^4.3.8",
-    "vue-eslint-parser": "^9.0.3",
-    "vue-tsc": "^1.0.24"
+    "typescript": "^5.3.3"
   },
-  "description": "Gx Design"
+  "authors": [
+    "gx12358 <gx12358@gmail.com> (https://github.com/gx12358)"
+  ]
 }

package/volar.d.ts

@@ -1,8 +1,8 @@
 // Auto generated component declarations
-declare module "vue" {
+declare module 'vue' {
   export interface GlobalComponents {
-    GProTable: typeof import("@gx-design-vue/pro-table")["GProTable"];
+    GProTable: typeof import('@gx-design-vue/pro-table')['GProTable'];
   }
 }
 
-export {};
+export {}

package/dist/components/ColumnSetting/hooks/useRefFunction/index.d.ts

@@ -1 +0,0 @@
-export declare const useRefFunction: <T extends (...args: any) => any>(reFunction: T) => (...rest: Parameters<T>) => ReturnType<T>;

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

@@ -1,35 +0,0 @@
-import type { PropType } from 'vue';
-import type { SettingExtraRender } from '../../types/SlotsTypings';
-export type ColumnSettingProps = {
-    draggable?: boolean;
-    checkable?: boolean;
-    extra?: SettingExtraRender;
-    checkedReset?: boolean;
-};
-declare const ColumnSetting: import("vue").DefineComponent<{
-    draggable: {
-        type: PropType<boolean | undefined>;
-        default: undefined;
-    };
-    checkable: {
-        type: PropType<boolean | undefined>;
-        default: undefined;
-    };
-    checkedReset: PropType<boolean | undefined>;
-    extra: PropType<SettingExtraRender>;
-}, () => 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<{
-    draggable: {
-        type: PropType<boolean | undefined>;
-        default: undefined;
-    };
-    checkable: {
-        type: PropType<boolean | undefined>;
-        default: undefined;
-    };
-    checkedReset: PropType<boolean | undefined>;
-    extra: PropType<SettingExtraRender>;
-}>>, {
-    checkable: boolean | undefined;
-    draggable: boolean | undefined;
-}>;
-export default ColumnSetting;

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

@@ -1,6 +0,0 @@
-import type { ProAliasToken } from '@gx-design-vue/pro-provider';
-export interface ProToken extends ProAliasToken {
-    componentCls: string;
-}
-declare const _default: (_prefixCls?: string | import("vue").Ref<string> | undefined) => import("ant-design-vue/es/theme/internal").UseComponentStyleResult;
-export default _default;

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

@@ -1,3 +0,0 @@
-import type { FunctionalComponent as FC } from 'vue';
-declare const DensityIcon: FC;
-export default DensityIcon;

package/dist/hooks/useColums.d.ts

@@ -1,24 +0,0 @@
-import type { Ref, ComputedRef } from 'vue';
-import type { ColumnsState } from './useColumnSetting';
-import type { ProTableProps } from '../types/TableTypings';
-import type { ProColumnType, ProColumnsType } from '../types/ColumnTypings';
-export type ConfigColumns = {
-    draggabled: ComputedRef<ProTableProps['draggabled']>;
-    neverScroll: ComputedRef<ProTableProps['neverScroll']>;
-    autoScroll: ComputedRef<ProTableProps['autoScroll']>;
-};
-type UseColumnsType = {
-    scroll: ComputedRef<ProTableProps['scroll']>;
-    breakpoint: ComputedRef<boolean>;
-    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>;
-    getProColumns: ComputedRef<ProColumnType<import("../typing").DefaultRecordType>[]>;
-    cacheProColumns: Ref<ProColumnsType<import("../typing").DefaultRecordType>>;
-    setColumns: (columnList: ProColumnsType<import("../typing").DefaultRecordType>) => void;
-    changeColumns: (columnState: Record<string, ColumnsState>) => void;
-    resizeColumnWidth: (w: number, col: ProColumnType) => void;
-};
-export {};