@polyv/vue-components 1.2.3 → 1.4.0

package/vue3/src/components/table/components/table-body-row/use-table-body-row.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef } from 'vue';
+import { VueProps } from '../../../../vue-utils';
+export declare const tableBodyRowProps: () => {
+    rowData: import('vue-types').VueTypeValidableDef<any, import('vue-types/dist/types').ValidatorFunction<any>> & {
+        required: true;
+    };
+    rowIndex: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    } & {
+        required: true;
+    };
+};
+export interface TableBodyRowInjectData {
+    /** 行数据 */
+    rowData: ComputedRef<any>;
+    /** 行索引 */
+    rowIndex: ComputedRef<number>;
+}
+export declare const useTableBodyRow: (options: {
+    props: VueProps<typeof tableBodyRowProps>;
+}) => {
+    rowData: ComputedRef<any>;
+    rowIndex: ComputedRef<number>;
+};
+export declare const useTableBodyRowInject: () => TableBodyRowInjectData;

package/vue3/src/components/table/components/table-body.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-colgroup/table-colgroup.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-fixed-shadow.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{
+    position: import('vue-types').VueTypeDef<"center" | "left" | "right"> & {
+        required: true;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+    position: import('vue-types').VueTypeDef<"center" | "left" | "right"> & {
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-footer/table-pagination.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-header/table-header.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-header/use-table-header-structure.d.ts

@@ -0,0 +1,4 @@
+import { TableColumnInstance } from '../../hooks/use-table-column/use-table-column';
+export declare const useTableHeaderStructure: () => {
+    headerStructure: import('vue').ComputedRef<TableColumnInstance[][]>;
+};

package/vue3/src/components/table/components/table-header-cell/header-cell-multiple.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-header-cell/header-cell-sort.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-header-cell/table-header-cell.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{
+    column: import('vue-types').VueTypeValidableDef<import('../../hooks/use-table-column/use-table-column').TableColumnInstance, import('vue-types/dist/types').ValidatorFunction<import('../../hooks/use-table-column/use-table-column').TableColumnInstance>> & {
+        required: true;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+    column: import('vue-types').VueTypeValidableDef<import('../../hooks/use-table-column/use-table-column').TableColumnInstance, import('vue-types/dist/types').ValidatorFunction<import('../../hooks/use-table-column/use-table-column').TableColumnInstance>> & {
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/vue3/src/components/table/components/table-header-cell/use-table-header-cell-class.d.ts

@@ -0,0 +1,4 @@
+import { TableHeaderCellInjectData } from './use-table-header-cell';
+export declare const useTableHeaderCellClass: (options: TableHeaderCellInjectData) => {
+    headerCellClass: import('vue').ComputedRef<string[]>;
+};

package/vue3/src/components/table/components/table-header-cell/use-table-header-cell.d.ts

@@ -0,0 +1,21 @@
+import { VueProps } from '../../../../vue-utils';
+import { TableColumnInstance } from '../../hooks/use-table-column/use-table-column';
+import { Ref } from 'vue';
+export declare const tableHeaderCellProps: () => {
+    column: import('vue-types').VueTypeValidableDef<TableColumnInstance, import('vue-types/dist/types').ValidatorFunction<TableColumnInstance>> & {
+        required: true;
+    };
+};
+export interface TableHeaderCellInjectData {
+    /** 表头单元格节点 */
+    headerCellRef: Ref<HTMLDivElement | undefined>;
+    /** 当前列实例 */
+    column: TableColumnInstance;
+}
+export declare const useTableHeaderCell: (options: {
+    props: VueProps<typeof tableHeaderCellProps>;
+}) => {
+    headerCellRef: Ref<HTMLDivElement | undefined>;
+    column: TableColumnInstance;
+};
+export declare const useTableHeaderCellInject: () => TableHeaderCellInjectData;

package/vue3/src/components/table/hooks/props-define.d.ts

@@ -0,0 +1,234 @@
+import { PageContent } from '../../../hooks/pagination/types';
+import { TableCellClassType, TableCellParams, TableCellStyleType, TableColumnType, TableRowClassType, TableRowKeyType, TableRowParams, TableRowStyleType, TableSortData } from '../types';
+export declare const tableProps: () => {
+    /**
+     * 表格数据
+     */
+    data: import('vue-types').VueTypeDef<any[] | PageContent<any>> & {
+        default: (() => any[]) | (() => PageContent<any>);
+    };
+    /**
+     * 表头高度
+     * @default 48
+     */
+    headerHeight: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 表头背景色
+     */
+    headerBgColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    /**
+     * 表格高度
+     */
+    height: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>>;
+    /**
+     * 最大高度
+     */
+    maxHeight: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>>;
+    /**
+     * 高亮行
+     * @default true
+     */
+    hoverRow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 高亮列
+     * @default true
+     */
+    hoverColumn: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 行键值
+     */
+    rowKey: import('vue-types').VueTypeDef<TableRowKeyType>;
+    /**
+     * 行的 className
+     */
+    rowClassName: import('vue-types').VueTypeDef<TableRowClassType>;
+    /**
+     * 行的样式
+     */
+    rowStyle: import('vue-types').VueTypeDef<TableRowStyleType>;
+    /**
+     * 单元格的 className
+     */
+    cellClassName: import('vue-types').VueTypeDef<TableCellClassType>;
+    /**
+     * 单元格的样式
+     */
+    cellStyle: import('vue-types').VueTypeDef<TableCellStyleType>;
+    /**
+     * 是否显示分页
+     * @propType PaginationPropsType、boolean
+     * @default false
+     */
+    pagination: import('vue-types').VueTypeDef<boolean | Partial<import('vue').ExtractPropTypes<{
+        "v-model-key": import('vue-types').VueTypeValidableDef<PageContent<unknown>, import('vue-types/dist/types').ValidatorFunction<PageContent<unknown>>>;
+        layout: import('vue-types').VueTypeValidableDef<("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[], import('vue-types/dist/types').ValidatorFunction<("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[]>> & {
+            default: () => ("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[];
+        };
+        pagerCount: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+            default: number;
+        };
+        pagerType: import('vue-types').VueTypeDef<"number" | "button"> & {
+            default: "number" | "button";
+        };
+        pageSizes: import('vue-types').VueTypeValidableDef<number[], import('vue-types/dist/types').ValidatorFunction<number[]>> & {
+            default: () => number[];
+        };
+        size: import('vue-types').VueTypeValidableDef<import('../../pagination').PaginationSize, import('vue-types/dist/types').ValidatorFunction<import('../../pagination').PaginationSize>> & {
+            default: import('../../pagination').PaginationSize;
+        };
+        hideOnSinglePage: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+            default: boolean;
+        };
+    }>>> & {
+        default: boolean | (() => Partial<import('vue').ExtractPropTypes<{
+            "v-model-key": import('vue-types').VueTypeValidableDef<PageContent<unknown>, import('vue-types/dist/types').ValidatorFunction<PageContent<unknown>>>;
+            layout: import('vue-types').VueTypeValidableDef<("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[], import('vue-types/dist/types').ValidatorFunction<("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[]>> & {
+                default: () => ("next" | "prev" | "pager" | "sizes" | "jumper" | "total-items" | "total-pages")[];
+            };
+            pagerCount: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+                default: number;
+            };
+            pagerType: import('vue-types').VueTypeDef<"number" | "button"> & {
+                default: "number" | "button";
+            };
+            pageSizes: import('vue-types').VueTypeValidableDef<number[], import('vue-types/dist/types').ValidatorFunction<number[]>> & {
+                default: () => number[];
+            };
+            size: import('vue-types').VueTypeValidableDef<import('../../pagination').PaginationSize, import('vue-types/dist/types').ValidatorFunction<import('../../pagination').PaginationSize>> & {
+                default: import('../../pagination').PaginationSize;
+            };
+            hideOnSinglePage: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+        }>>);
+    };
+    /**
+     * 排序
+     */
+    sort: import('vue-types').VueTypeValidableDef<TableSortData, import('vue-types/dist/types').ValidatorFunction<TableSortData>>;
+    /**
+     * 高亮排序列
+     * @default true
+     */
+    highlightSorted: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 是否显示纵向边框
+     * @default false
+     */
+    border: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export declare const tableEmits: () => {
+    /**
+     * 分页修改
+     * @cbName 分页内容
+     * @cbType PageContent
+     */
+    'page-change': import('../../../vue-utils').EmitFuncType<PageContent<unknown>>;
+    /**
+     * 排序修改
+     * @cbName 排序数据
+     * @cbType TableSortData
+     */
+    'sort-change': import('../../../vue-utils').EmitFuncType<TableSortData | undefined>;
+};
+export declare const tableColumnProps: () => {
+    /**
+     * 绑定值，支持 v-model
+     */
+    "v-model-key": import('vue-types').VueTypeValidableDef<any, import('vue-types/dist/types').ValidatorFunction<any>>;
+    /**
+     * 列类型
+     */
+    type: import('vue-types').VueTypeValidableDef<TableColumnType, import('vue-types/dist/types').ValidatorFunction<TableColumnType>>;
+    /**
+     * 列头文字
+     */
+    title: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    /**
+     * 字段名称，对应数据的字段名
+     */
+    prop: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    /**
+     * 列宽度
+     */
+    width: import('vue-types').VueTypeDef<string | number>;
+    /**
+     * 列最小宽度
+     */
+    minWidth: import('vue-types').VueTypeDef<string | number>;
+    /**
+     * 列是否固定
+     */
+    fixed: import('vue-types').VueTypeDef<"left" | "right">;
+    /**
+     * 多选最大选择数量
+     */
+    multipleMax: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 多选是否禁用
+     */
+    multipleDisabled: import('vue-types').VueTypeValidableDef<(params: TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: TableRowParams) => boolean>>;
+    /**
+     * 单选是否禁用
+     */
+    singleDisabled: import('vue-types').VueTypeValidableDef<(params: TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: TableRowParams) => boolean>>;
+    /**
+     * 表头提示
+     */
+    headerTips: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 是否显示排序
+     * @default false
+     */
+    sortable: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 排序字段名
+     */
+    sortName: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    /**
+     * 超过宽度自动省略
+     * @default false
+     */
+    ellipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export declare const tableColumnEmits: () => {};
+export interface TableColumnHeaderSlotData {
+    /** 渲染的宽度 */
+    renderWidth: number;
+    /** 列索引 */
+    columnIndex: number;
+}
+export interface TableColumnCellSlotData<RowData extends object = any> extends TableCellParams<RowData> {
+}
+export interface TableColumnSlots {
+    /**
+     * 单元格插槽
+     */
+    default?: TableCellParams;
+    /**
+     * 嵌套列
+     */
+    column?: void;
+    /**
+     * 列头插槽
+     */
+    header?: TableColumnHeaderSlotData;
+}

package/vue3/src/components/table/hooks/table-data/use-row-key.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 获取表格行键值
+ */
+export declare const useRowKey: () => {
+    hasRowKey: () => boolean;
+    getRowKey: (rowData: any) => any;
+    getRenderRowKey: (rowData: any, rowIndex: number) => string;
+};

package/vue3/src/components/table/hooks/table-data/use-table-multiple.d.ts

@@ -0,0 +1,10 @@
+import { TableColumnInstance } from '../../hooks/use-table-column/use-table-column';
+export declare const useTableMultiple: (column: TableColumnInstance) => {
+    getColumnModelValue: () => any[];
+    multipleIsDisabled: (rowData: any, rowIndex: number) => boolean;
+    inModelValue: (rowData: any) => boolean;
+    appendModelValue: (rowData: any) => void;
+    removeModelValue: (rowData: any) => void;
+    checkModelValue: (rowData: any) => void;
+    deleteRowData: (list: any[], rowData: any) => any[];
+};

package/vue3/src/components/table/hooks/table-data/use-table-single.d.ts

@@ -0,0 +1,8 @@
+import { TableColumnInstance } from '../../hooks/use-table-column/use-table-column';
+export declare const useTableSingle: (column: TableColumnInstance) => {
+    getColumnModelValue: () => any;
+    singleIsDisabled: (rowData: any, rowIndex: number) => boolean;
+    isSelected: (rowData: any) => boolean;
+    setModelValue: (rowData: any) => void;
+    checkModelValue: (rowData: any) => void;
+};

package/vue3/src/components/table/hooks/use-table/use-column-computed.d.ts

@@ -0,0 +1,55 @@
+import { TableColumnInstance } from '../use-table-column/use-table-column';
+import { ColumnListInstance } from './use-column-list';
+import { TableElementInstance } from './use-table-element';
+import { TableColumnType } from '../../types';
+/** 处理表格列的计算 */
+export declare const useColumnComputed: (options: TableElementInstance & {
+    leftColumnListInstance: ColumnListInstance;
+    centerColumnListInstance: ColumnListInstance;
+    rightColumnListInstance: ColumnListInstance;
+}) => {
+    allColumnList: import('vue').ComputedRef<{
+        columnId: string;
+        columnProps: {
+            readonly ellipsis: boolean;
+            readonly multipleMax: number;
+            readonly headerTips: string;
+            readonly sortable: boolean;
+            readonly title?: string | undefined;
+            readonly "v-model-key"?: any;
+            readonly fixed?: "left" | "right" | undefined;
+            readonly type?: TableColumnType | undefined;
+            readonly width?: string | number | undefined;
+            readonly minWidth?: string | number | undefined;
+            readonly prop?: string | undefined;
+            readonly multipleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly singleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly sortName?: string | undefined;
+        };
+        getModelValue: () => any;
+        updateModelValue: (value: any) => void;
+        setRenderWidth: (width: number) => void;
+        getRenderWidth: () => number;
+        setColumnIndex: (index: number) => void;
+        getColumnIndex: () => number;
+        getStickyStatus: () => boolean;
+        setStickyPosition: (num: number) => void;
+        getStickyStyle: () => Record<string, string>;
+        hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+        getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+        getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+        addChildrenColumn: (column: TableColumnInstance) => void;
+        getChildrenColumns: () => TableColumnInstance[];
+        level: number;
+        setColSpan: (num: number) => void;
+        getColSpan: () => number;
+        setRowSpan: (num: number) => void;
+        getRowSpan: () => number;
+        getColumnSortName: () => string | undefined;
+        isCurrentSort: () => boolean;
+        changeSortOrder: (order: import('../../types').TableSortOrder | undefined) => void;
+        toggleSortOrder: () => import('../../types').TableSortOrder | undefined;
+    }[]>;
+    allColumnWidth: import('vue').ComputedRef<number>;
+    hasHorizontalScroll: import('vue').ComputedRef<boolean>;
+};

package/vue3/src/components/table/hooks/use-table/use-column-list.d.ts

@@ -0,0 +1,99 @@
+import { TableColumnInstance } from '../use-table-column/use-table-column';
+import { TableColumnRenderPosition } from '../../types';
+export declare const useColumnListStore: () => {
+    columnList: import('vue').Ref<{
+        columnId: string;
+        columnProps: {
+            readonly ellipsis: boolean;
+            readonly multipleMax: number;
+            readonly headerTips: string;
+            readonly sortable: boolean;
+            readonly title?: string | undefined;
+            readonly "v-model-key"?: any;
+            readonly fixed?: "left" | "right" | undefined;
+            readonly type?: import('../../types').TableColumnType | undefined;
+            readonly width?: string | number | undefined;
+            readonly minWidth?: string | number | undefined;
+            readonly prop?: string | undefined;
+            readonly multipleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly singleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly sortName?: string | undefined;
+        };
+        getModelValue: () => any;
+        updateModelValue: (value: any) => void;
+        setRenderWidth: (width: number) => void;
+        getRenderWidth: () => number;
+        setColumnIndex: (index: number) => void;
+        getColumnIndex: () => number;
+        getStickyStatus: () => boolean;
+        setStickyPosition: (num: number) => void;
+        getStickyStyle: () => Record<string, string>;
+        hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+        getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+        getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+        addChildrenColumn: (column: TableColumnInstance) => void;
+        getChildrenColumns: () => TableColumnInstance[];
+        level: number;
+        setColSpan: (num: number) => void;
+        getColSpan: () => number;
+        setRowSpan: (num: number) => void;
+        getRowSpan: () => number;
+        getColumnSortName: () => string | undefined;
+        isCurrentSort: () => boolean;
+        changeSortOrder: (order: import('../../types').TableSortOrder | undefined) => void;
+        toggleSortOrder: () => import('../../types').TableSortOrder | undefined;
+    }[]>;
+    addColumn: (column: TableColumnInstance) => void;
+    removeColumn: (column: TableColumnInstance) => void;
+};
+export type ColumnListStoreInstance = ReturnType<typeof useColumnListStore>;
+export declare const useColumnList: (position: TableColumnRenderPosition) => {
+    columnList: import('vue').Ref<{
+        columnId: string;
+        columnProps: {
+            readonly ellipsis: boolean;
+            readonly multipleMax: number;
+            readonly headerTips: string;
+            readonly sortable: boolean;
+            readonly title?: string | undefined;
+            readonly "v-model-key"?: any;
+            readonly fixed?: "left" | "right" | undefined;
+            readonly type?: import('../../types').TableColumnType | undefined;
+            readonly width?: string | number | undefined;
+            readonly minWidth?: string | number | undefined;
+            readonly prop?: string | undefined;
+            readonly multipleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly singleDisabled?: ((params: import('../../types').TableRowParams) => boolean) | undefined;
+            readonly sortName?: string | undefined;
+        };
+        getModelValue: () => any;
+        updateModelValue: (value: any) => void;
+        setRenderWidth: (width: number) => void;
+        getRenderWidth: () => number;
+        setColumnIndex: (index: number) => void;
+        getColumnIndex: () => number;
+        getStickyStatus: () => boolean;
+        setStickyPosition: (num: number) => void;
+        getStickyStyle: () => Record<string, string>;
+        hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+        getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+        getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+        addChildrenColumn: (column: TableColumnInstance) => void;
+        getChildrenColumns: () => TableColumnInstance[];
+        level: number;
+        setColSpan: (num: number) => void;
+        getColSpan: () => number;
+        setRowSpan: (num: number) => void;
+        getRowSpan: () => number;
+        getColumnSortName: () => string | undefined;
+        isCurrentSort: () => boolean;
+        changeSortOrder: (order: import('../../types').TableSortOrder | undefined) => void;
+        toggleSortOrder: () => import('../../types').TableSortOrder | undefined;
+    }[]>;
+    addColumn: (column: TableColumnInstance) => void;
+    removeColumn: (column: TableColumnInstance) => void;
+    position: "center" | "left" | "right";
+    columnCount: import('vue').ComputedRef<number>;
+    columnWidthTotal: import('vue').ComputedRef<number>;
+};
+export type ColumnListInstance = ReturnType<typeof useColumnList>;

package/vue3/src/components/table/hooks/use-table/use-table-element.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, Ref } from 'vue';
+export interface TableElementInstance {
+    /** 外层容器 */
+    wrapRef: Ref<HTMLDivElement | undefined>;
+    /** 外层容器宽度 */
+    wrapWidth: Ref<number>;
+    /** 表格头部外层容器 */
+    headerWrapRef: Ref<HTMLDivElement | undefined>;
+    /** 表格头部外层容器尺寸 */
+    headerWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 表格主体外层容器 */
+    bodyWrapRef: Ref<HTMLDivElement | undefined>;
+    /** 表格主体外层容器尺寸 */
+    bodyWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 表格主体 */
+    bodyRef: Ref<HTMLDivElement | undefined>;
+    /** 表格主体尺寸 */
+    bodySize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 横向滚动条 */
+    horizontalScrollbarRef: Ref<HTMLDivElement | undefined>;
+    /** 纵向滚动条 */
+    verticalScrollbarRef: Ref<HTMLDivElement | undefined>;
+}
+/** 表格元素 */
+export declare const useTableElement: () => TableElementInstance;
+export declare const useTableElementInject: () => TableElementInstance;

package/vue3/src/components/table/hooks/use-table/use-table-pagination.d.ts

@@ -0,0 +1,12 @@
+import { VueProps } from '../../../../vue-utils';
+import { tableProps } from '../props-define';
+import { ComputedRef, Ref } from 'vue';
+import { PageContent } from '../../../../hooks/pagination/types';
+export interface TablePaginationInjectData {
+    propsData: ComputedRef<PageContent>;
+    paginationModelValue: Ref<PageContent>;
+}
+export declare const useTablePagination: (options: {
+    tableProps: VueProps<typeof tableProps>;
+}) => void;
+export declare const useTablePaginationInject: () => TablePaginationInjectData;

package/vue3/src/components/table/hooks/use-table/use-table-render-data.d.ts

@@ -0,0 +1,13 @@
+import { VueProps } from '../../../../vue-utils';
+import { tableProps } from '../props-define';
+import { ComputedRef } from 'vue';
+export interface TableRenderDataInject {
+    /** 表格渲染的数据 */
+    renderData: ComputedRef<any[]>;
+}
+export declare const useTableRenderData: (options: {
+    tableProps: VueProps<typeof tableProps>;
+}) => {
+    renderData: ComputedRef<any[]>;
+};
+export declare const useTableRenderDataInject: () => TableRenderDataInject;

package/vue3/src/components/table/hooks/use-table/use-table-scroll.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef, Ref } from 'vue';
+import { TableElementInstance } from './use-table-element';
+export interface TableScrollInjectData {
+    /**
+     * 当前横向滚动位置，left-最左侧，center-中间，right-最右侧
+     */
+    scrollXPosition: Ref<'start' | 'middle' | 'end'>;
+    /**
+     * 是否显示横向滚动
+     */
+    hasHorizontalScroll: ComputedRef<boolean>;
+    /**
+     * 是否显示纵向滚动
+     */
+    hasVerticalScroll: ComputedRef<boolean>;
+    /**
+     * 横向滚动事件
+     */
+    onHorizontalScrollEvent: (event: Event) => void;
+}
+/** 处理表格滚动 */
+export declare const useTableScroll: (options: TableElementInstance & {
+    allColumnWidth: ComputedRef<number>;
+}) => {
+    hasHorizontalScroll: ComputedRef<boolean>;
+    hasVerticalScroll: ComputedRef<boolean>;
+};
+export declare const useTableScrollInject: () => TableScrollInjectData;