bkui-vue 2.0.1-beta.9 → 2.0.1-beta.91

package/lib/table/const.d.ts

@@ -1,18 +1,18 @@
-import type { ComputedRef } from 'vue';
 import type { Language } from '../locale';
+import type { ComputedRef } from 'vue';
 export declare const enum BORDER_OPTION {
-    NONE = "none",
-    ROW = "row",
     COL = "col",
+    HORIZONTAL = "horizontal",
+    NONE = "none",
     OUTER = "outer",
-    HORIZONTAL = "horizontal"
+    ROW = "row"
 }
 /**
  * 鼠标划过行样式
  */
 export declare const enum ROW_HOVER {
-    HIGHLIGHT = "highlight",
-    AUTO = "auto"
+    AUTO = "auto",
+    HIGHLIGHT = "highlight"
 }
 export declare const ROW_HOVER_OPTIONS: ROW_HOVER[];
 /**
@@ -31,6 +31,7 @@ export declare const TABLE_ROW_ATTRIBUTE: {
     ROW_SOURCE_DATA: string;
     ROW_SKIP_CFG: string;
     ROW_SPAN: string;
+    ROW_HEIGHT: string;
 };
 export declare const COLUMN_ATTRIBUTE: {
     COL_UID: string;
@@ -41,9 +42,21 @@ export declare const COLUMN_ATTRIBUTE: {
     COL_SORT_FN: string;
     COL_SORT_SCOPE: string;
     COL_FILTER_FN: string;
+    COL_FILTER_VALUES: string;
+    COL_FILTER_OBJ: string;
     COL_FILTER_SCOPE: string;
     COL_IS_DRAG: string;
     COL_SPAN: string;
+    COL_CELL_RENDER: string;
+    COL_TEXT_RENDER: string;
+    COL_RESIZEABLE: string;
+    COL_FIXED_STYLE: string;
+    COL_RECT: string;
+    HEAD_CELL_RENDER: string;
+    HEAD_TEXT_RENDER: string;
+    SELECTION_DISABLED: string;
+    SELECTION_INDETERMINATE: string;
+    SELECTION_VAL: string;
     WIDTH: string;
     CALC_WIDTH: string;
     RESIZE_WIDTH: string;
@@ -53,7 +66,7 @@ export declare const COLUMN_ATTRIBUTE: {
 /**
  * Y 轴滚动条宽度
  */
-export declare const SCROLLY_WIDTH = 0;
+export declare const SCROLLY_WIDTH = 8;
 /**
  * 默认行高
  */
@@ -95,16 +108,16 @@ export declare const TB_FOOT_HEIGHT = 60;
  */
 export declare const enum SORT_OPTION {
     ASC = "asc",
+    CUSTOM = "custom",
     DESC = "desc",
-    NULL = "null",
-    CUSTOM = "custom"
+    NULL = "null"
 }
 export declare const SORT_OPTIONS: SORT_OPTION[];
 /**
  * 列宽最小设置
  */
 export declare const COL_MIN_WIDTH = 80;
-export type IEmptyObject = {};
+export type IEmptyObject = Record<string, never>;
 /**
  * 全选对象
  */

package/lib/table/events.d.ts

@@ -1,35 +1,27 @@
 import { SORT_OPTION } from './const';
 import { Column, IColumnActive } from './props';
-export declare const enum EVENTS {
-    /** 点击排序事件 */
-    ON_SORT_BY_CLICK = "onSortByClick",
-    ON_FILTER_CLICK = "onFilterClick",
-    ON_SETTING_CHANGE = "onSettingChange",
-    ON_ROW_EXPAND_CLICK = "onRowExpandClick",
-    ON_ROW_CHECK = "onRowCheck"
-}
 export declare const enum EMIT_EVENTS {
-    COLUMN_PICK = "columnPick",
-    COLUMN_SORT = "columnSort",
+    CELL_CLICK = "cellClick",
+    CELL_DBL_CLICK = "cellDblclick",
     COLUMN_FILTER = "columnFilter",
     COLUMN_FILTER_SAVE = "colFilterSave",
+    COLUMN_PICK = "columnPick",
+    COLUMN_SORT = "columnSort",
+    DRAG_END = "dragend",
+    NATIVE_CLICK = "click",
+    NATIVE_DBL_CLICK = "dblclick",
+    PAGE_LIMIT_CHANGE = "pageLimitChange",
+    PAGE_VALUE_CHANGE = "pageValueChange",
     ROW_CLICK = "rowClick",
     ROW_DBL_CLICK = "rowDblclick",
     ROW_EXPAND_CLICK = "rowExpand",
     ROW_MOUSE_ENTER = "rowMouseEnter",
     ROW_MOUSE_LEAVE = "rowMouseLeave",
-    PAGE_LIMIT_CHANGE = "pageLimitChange",
-    PAGE_VALUE_CHANGE = "pageValueChange",
-    SETTING_CHANGE = "settingChange",
-    SCROLL_BOTTOM = "scrollBottom",
     ROW_SELECT = "select",
     ROW_SELECT_ALL = "selectAll",
     ROW_SELECT_CHANGE = "selectionChange",
-    CELL_CLICK = "cellClick",
-    CELL_DBL_CLICK = "cellDblclick",
-    NATIVE_CLICK = "click",
-    NATIVE_DBL_CLICK = "dblclick",
-    DRAG_END = "dragend"
+    SCROLL_BOTTOM = "scrollBottom",
+    SETTING_CHANGE = "settingChange"
 }
 export declare const EVENT_COL_PICK: (_cols: IColumnActive[]) => boolean;
 export declare const EVENT_COL_FILTER: (_args: {
@@ -50,13 +42,13 @@ export declare const EVENT_MOUSE_FN: (_e: MouseEvent, _row: any, _index: number,
 export declare const EVENT_EXPAND_FN: (_args: {
     row: any;
     column: Column;
-    index: Number;
+    index: number;
     rows: any[];
     e: MouseEvent;
 }) => boolean;
 export declare const EVENT_ROW_SELECT_FN: (_args: {
     row: any;
-    index: Number;
+    index: number;
     checked: string;
     data: any[];
 }) => boolean;
@@ -66,18 +58,13 @@ export declare const EVENT_ROW_SELECT_ALL_FN: (_args: {
 }) => boolean;
 export declare const EVENT_ROW_SELECT_CHANGE_FN: (_args: {
     row: any;
-    index: Number;
+    index: number;
     checked: string;
     data: any[];
     isAll: boolean;
 }) => boolean;
 export declare const EVENT_PAGE_FN: (_arg: number) => boolean;
-export declare const EVENT_SETTING_FN: (_args: {
-    checked: string[];
-    size: string;
-    height: number;
-    fields: Array<Record<string, any>>;
-}) => boolean;
+export declare const EVENT_SETTING_FN: (_args: any) => boolean;
 export declare const EVENT_CELL_FN: (_args: {
     event: MouseEvent;
     row: any;
@@ -99,90 +86,7 @@ export declare const EVENT_DRAGEND_FN: (_args: {
     sourceEvent: DragEvent;
     data: any[];
 }) => boolean;
-export declare const EMIT_EVENT_TYPES: {
-    columnPick: (_cols: IColumnActive[]) => boolean;
-    columnFilter: (_args: {
-        checked: string[];
-        column: Column;
-        index: number;
-    }) => boolean;
-    columnSort: (_args: {
-        column: Column;
-        index: number;
-        type: SORT_OPTION;
-    }) => boolean;
-    colFilterSave: (_args: {
-        column: Column;
-        values: any[];
-    }) => boolean;
-    rowClick: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;
-    rowDblclick: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;
-    rowExpand: (_args: {
-        row: any;
-        column: Column;
-        index: Number;
-        rows: any[];
-        e: MouseEvent;
-    }) => boolean;
-    select: (_args: {
-        row: any;
-        index: Number;
-        checked: string;
-        data: any[];
-    }) => boolean;
-    selectAll: (_args: {
-        checked: string;
-        data: any[];
-    }) => boolean;
-    selectionChange: (_args: {
-        row: any;
-        index: Number;
-        checked: string;
-        data: any[];
-        isAll: boolean;
-    }) => boolean;
-    pageLimitChange: (_arg: number) => boolean;
-    pageValueChange: (_arg: number) => boolean;
-    settingChange: (_args: {
-        checked: string[];
-        size: string;
-        height: number;
-        fields: Array<Record<string, any>>;
-    }) => boolean;
-    scrollBottom: (_args: {
-        translateX: number;
-        translateY: number;
-        scrollTop: number;
-        scrollLeft: number;
-        bottom: number;
-    }) => boolean;
-    cellClick: (_args: {
-        event: MouseEvent;
-        row: any;
-        column: Column;
-        cell: {
-            getValue: () => string;
-        };
-        rowIndex: number;
-        columnIndex: number;
-    }) => boolean;
-    cellDblclick: (_args: {
-        event: MouseEvent;
-        row: any;
-        column: Column;
-        cell: {
-            getValue: () => string;
-        };
-        rowIndex: number;
-        columnIndex: number;
-    }) => boolean;
-    rowMouseEnter: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;
-    rowMouseLeave: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;
-    dragend: (_args: {
-        sourceEvent: DragEvent;
-        data: any[];
-    }) => boolean;
-};
+export declare const EMIT_EVENT_TYPES: Record<string, (...args: any[]) => boolean>;
 export declare const CELL_EVENT_TYPES: {
     click: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;
     dblclick: (_e: MouseEvent, _row: any, _index: number, _rows: any[], _this: any) => boolean;

package/lib/table/hooks/use-cell.d.ts

@@ -0,0 +1,20 @@
+import { SetupContext } from 'vue';
+import { Column, TablePropTypes } from '../props';
+import { UseColumns } from './use-columns';
+import { UseRows } from './use-rows';
+import { UseMultiShiftKey } from './use-shift-key';
+type CellRenderArgsType = {
+    props: TablePropTypes;
+    rows: UseRows;
+    ctx: SetupContext;
+    columns: UseColumns;
+    row: Record<string, object>;
+    index: number;
+    column: Column;
+    isChild: boolean;
+    multiShiftKey: UseMultiShiftKey;
+};
+declare const _default: ({ props, rows, ctx, columns, row, index, column, isChild, multiShiftKey, }: CellRenderArgsType) => {
+    renderCell: () => any;
+};
+export default _default;

package/lib/table/hooks/use-column-resize.d.ts

@@ -0,0 +1,7 @@
+import { UseColumns } from './use-columns';
+declare const _default: (columns: UseColumns, { afterResize }: {
+    afterResize: any;
+}) => {
+    dragOffsetX: import("vue").Ref<number>;
+};
+export default _default;

package/lib/table/hooks/use-column-template.d.ts

@@ -0,0 +1,5 @@
+import { VNode, VNodeNormalizedChildren } from 'vue';
+declare const _default: () => {
+    resolveColumns: (children: VNode[] | VNodeNormalizedChildren) => any[];
+};
+export default _default;

package/lib/table/hooks/use-columns.d.ts

@@ -0,0 +1,69 @@
+import { IEmptyObject } from '../const';
+import { Column, IHeadGroup, Settings, TablePropTypes } from '../props';
+declare const useColumns: (props: TablePropTypes) => {
+    needColSpan: import("vue").ComputedRef<boolean>;
+    needRowSpan: import("vue").ComputedRef<boolean>;
+    tableColumnSchema: WeakMap<object, any> & Omit<WeakMap<object, any>, keyof WeakMap<any, any>>;
+    tableColumnList: any[];
+    visibleColumns: Column[];
+    debounceUpdateColumns: import("lodash").DebouncedFunc<(columns: any, onComplete?: any) => void>;
+    sortColumns: any[];
+    filterColumns: any[];
+    columnGroup: Column[][];
+    columnGroupMap: WeakMap<Column, IHeadGroup>;
+    clearColumnSort: () => void;
+    clearSelectionAll: () => void;
+    formatColumns: () => void;
+    flatColumnTemplate: (cols: Column[]) => any[];
+    isHiddenColumn: (col: Column) => any;
+    getColumnId: (col: Column) => any;
+    getColumnOrderWidth: (col: Column, orders?: string[]) => number;
+    getColumnAttribute: (col: Column | IEmptyObject, attributeName: string) => any;
+    getHeadColumnClass: (column: Column, colIndex: number) => {
+        [x: string]: boolean;
+        column_fixed: boolean;
+        column_fixed_left: boolean;
+        column_fixed_right: boolean;
+    };
+    getColumnClass: (column: Column, colIndex: number) => {
+        [x: string]: boolean;
+        column_fixed: boolean;
+        column_fixed_left: boolean;
+        column_fixed_right: boolean;
+    };
+    getFixedStlye: (column: Column) => any;
+    getColumnRect: (column: Column) => any;
+    getColumnCustomClass: (column: any, row?: Record<string, object>) => any;
+    getColumnRefAttribute: (col: Column | IEmptyObject, attributeName: string) => any;
+    getColumnCalcWidth: (column: Column) => any;
+    getColumnWidth: (column: Column) => any;
+    getLeftColumnsWidth: (col: Column, includingSelf?: boolean) => number;
+    getGroupAttribute: (group: Column) => IHeadGroup;
+    getPreColumn: (col: Column) => Column;
+    getColumnIndex: (col: Column) => number;
+    resolveEventListener: (col: Column, index: number) => Record<string, (...args: any[]) => void> & {
+        [x: string]: (e: MouseEvent) => void;
+    };
+    setColumnIsHidden: (column: Column, value?: boolean) => void;
+    setColumnResizeWidth: (column: Column, value: number) => void;
+    setColumnSortOption: (column: Column, option: Record<string, object>) => void;
+    setColumnFilterOption: (column: Column, option: Record<string, object>) => void;
+    setColumnAttributeBySettings: (settings: Settings, checkedVal?: string[]) => void;
+    setColumnAttribute: (col: Column, attrName: string, attrValue: string | number | boolean | object | Record<string, object> | Record<string, object>[] | ((...args: any[]) => boolean | number | string | void)) => void;
+    setColumnSortActive: (column: Column, active: boolean) => void;
+    setFixedStyle: (column: Column, style: {
+        left?: string;
+        right?: string;
+    }) => void;
+    setColumnRect: (col: any, { left, right, width, height }: {
+        left?: number;
+        right?: number;
+        width?: number;
+        height?: number;
+    }) => void;
+    setVisibleColumns: () => void;
+    setNextColumnWidth: (col: Column, newWidth: number) => void;
+    resolveColsCalcWidth: (width: number) => void;
+};
+export type UseColumns = ReturnType<typeof useColumns>;
+export default useColumns;

package/lib/table/{plugins → hooks}/use-draggable.d.ts

@@ -1,7 +1,7 @@
 import { SetupContext } from 'vue';
 import { TablePropTypes } from '../props';
-import { ITableResponse } from '../use-attributes';
-declare const _default: (props: TablePropTypes, resp: ITableResponse, ctx: SetupContext<any>) => {
+import { UseRows } from './use-rows';
+declare const _default: (props: TablePropTypes, rows: UseRows, ctx: SetupContext) => {
     onDragenter?: undefined;
     onDragleave?: undefined;
     onDragstart?: undefined;

package/lib/table/hooks/use-fixed-column.d.ts

@@ -0,0 +1,10 @@
+import { TablePropTypes } from '../props';
+import { UseColumns } from './use-columns';
+/**
+ * 固定列Hooks
+ */
+declare const _default: (_props: TablePropTypes, columns: UseColumns) => {
+    renderFixedRows: () => JSX.Element[];
+    resolveFixedColumnStyle: () => void;
+};
+export default _default;

package/lib/table/hooks/use-head.d.ts

@@ -0,0 +1,16 @@
+import { SetupContext } from 'vue';
+import { Column, TablePropTypes } from '../props';
+import { UseColumns } from './use-columns';
+import { UseRows } from './use-rows';
+declare const _default: ({ props, columns, rows, ctx, column, index, }: {
+    props: TablePropTypes;
+    columns: UseColumns;
+    ctx: SetupContext;
+    column: Column;
+    index: number;
+    rows: UseRows;
+    rowIndex: number;
+}) => {
+    getTH: () => JSX.Element;
+};
+export default _default;

package/lib/table/hooks/use-layout.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+import { Column, TablePropTypes } from '../props';
+declare const _default: (props: TablePropTypes, ctx: any) => {
+    renderContainer: (childrend: any) => JSX.Element;
+    renderHeader: (childrend?: any, settings?: any, fixedRows?: any) => JSX.Element;
+    renderBody: (list: any, childrend?: any, fixedRows?: any) => JSX.Element;
+    renderFooter: (childrend?: any) => JSX.Element;
+    renderFixedBottom: () => JSX.Element;
+    getBodyHeight: (height: any) => number;
+    setBodyHeight: (height: number, withHeadFoot?: boolean) => void;
+    setVirtualBodyHeight: (height: number) => void;
+    setFootHeight: (height: number) => void;
+    setTranslateX: (val: number) => void;
+    setDragOffsetX: (val: number) => void;
+    setFixedColumns: (values: Column[]) => void;
+    setOffsetRight: () => void;
+    setLineHeight: (val: number | ((...args: any[]) => number)) => void;
+    setHeaderRowCount: (val: number) => void;
+    initRootStyleVars: () => void;
+    refRoot: Ref<HTMLElement>;
+    refHead: Ref<HTMLElement>;
+    refBody: Ref<any>;
+    refFooter: Ref<any>;
+};
+export default _default;

package/lib/table/hooks/use-pagination.d.ts

@@ -0,0 +1,16 @@
+import { TablePropTypes } from '../props';
+declare const usePagination: (props: TablePropTypes) => {
+    options: {
+        enabled: boolean;
+        count: number;
+        limit: number;
+        current: number;
+        align: string;
+        layout: string[];
+    };
+    isShowPagination: import("vue").ComputedRef<boolean>;
+    setPagination: (option: Record<string, unknown>) => void;
+    disabledPagination: (disable?: boolean) => void;
+};
+export type UsePagination = ReturnType<typeof usePagination>;
+export default usePagination;

package/lib/table/hooks/use-render.d.ts

@@ -0,0 +1,21 @@
+import { SetupContext } from 'vue';
+import { TablePropTypes } from '../props';
+import { UseColumns } from './use-columns';
+import { UsePagination } from './use-pagination';
+import { UseRows } from './use-rows';
+type RenderType = {
+    props: TablePropTypes;
+    ctx: SetupContext;
+    columns: UseColumns;
+    rows: UseRows;
+    pagination: UsePagination;
+};
+declare const _default: ({ props, ctx, columns, rows, pagination }: RenderType) => {
+    renderColumns: () => JSX.Element;
+    renderTBody: (list?: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | JSX.Element;
+    renderTFoot: () => JSX.Element;
+    setDragEvents: (events: Record<string, () => void>) => void;
+};
+export default _default;

package/lib/table/hooks/use-rows.d.ts

@@ -0,0 +1,30 @@
+import { IEmptyObject } from '../const';
+import { TablePropTypes } from '../props';
+declare const useRows: (props: TablePropTypes) => {
+    setRowIndex: (row: Record<string, unknown>, index: number) => void;
+    setRowExpand: (row: Record<string, unknown>, isExpand: boolean) => void;
+    isRowChecked: (row: Record<string, unknown>, index: number) => any;
+    setPageRowList: (rowList: Record<string, unknown>[]) => void;
+    setTableRowList: (data: unknown[]) => void;
+    clearSelection: () => void;
+    formatDataSchema: () => void;
+    toggleRowSelection: (row: Record<string, unknown>) => void;
+    setRowSelectionAll: (val: boolean) => void;
+    setRowSelection: (row: Record<string, unknown>, isSelected: boolean, index?: number) => void;
+    setAllRowExpand: (value?: boolean) => void;
+    setRowHeight: (height: number, row?: any) => void;
+    setTableIsNeedRowSpan: (val: boolean) => void;
+    getRowAttribute: (item: IEmptyObject | object, attrName: string) => any;
+    getRowSelection: () => any[];
+    getRowIndeterminate: () => any;
+    getRowCheckedAllValue: () => any;
+    getCurrentPageRowsHeight: () => any;
+    changePageRowIndex: (sourceIndex: any, targetIndex: any) => void;
+    toggleAllSelection: (value?: boolean) => void;
+    getRowHeight: (row?: any, index?: any, type?: any) => number;
+    tableRowList: import("vue").Ref<any[]>;
+    tableRowSchema: WeakMap<object, any> & Omit<WeakMap<object, any>, keyof WeakMap<any, any>>;
+    pageRowList: any[];
+};
+export type UseRows = ReturnType<typeof useRows>;
+export default useRows;

package/lib/table/hooks/use-settings.d.ts

@@ -0,0 +1,136 @@
+import { SetupContext } from 'vue';
+import { Column, TablePropTypes } from '../props';
+import { UseColumns } from './use-columns';
+declare const useSettings: (props: TablePropTypes, ctx: SetupContext, columns: UseColumns, afterSetting: any) => {
+    options: {
+        enabled: boolean;
+        fields: {
+            label?: import("../props").LabelFunctionString;
+            field: import("../props").LabelFunctionString & (string | number | true | ((_column: any, _index: any) => string | number | boolean | JSX.Element));
+            render?: import("../props").RenderFunctionString;
+            disabled?: boolean;
+            renderHead?: import("../props").RenderFunctionString;
+            width?: string | number;
+            minWidth?: string | number;
+            columnKey?: string;
+            showOverflowTooltip?: boolean | {
+                content: string | ((col: Column, row: Record<string, object>) => string);
+                disabled?: boolean | ((col: Column, row: Record<string, object>) => boolean);
+                allowHtml?: boolean;
+                watchCellResize?: boolean;
+                mode?: "auto" | "static";
+                popoverOption?: Record<string, object>;
+                resizerWay?: import("../props").ResizerWay;
+                showHead?: boolean;
+            };
+            type?: string;
+            fixed?: string | boolean;
+            resizable?: boolean;
+            sort?: string | boolean | {
+                sortFn?: (...args: any[]) => number;
+                sortScope?: import("../props").SortScope;
+                value?: import("../const").SORT_OPTION;
+            };
+            filter?: string | boolean | {
+                list: {
+                    label: string;
+                    text?: string;
+                    value: string;
+                    tipKey?: string;
+                }[];
+                filterFn?: (...args: any[]) => boolean;
+                match?: import("../props").FullEnum;
+                checked?: string[];
+                filterScope?: import("../props").SortScope;
+                btnSave?: string | boolean;
+                btnReset?: string | boolean;
+                height?: number;
+                maxHeight?: number;
+            };
+            colspan?: import("../props").SpanFunctionString;
+            rowspan?: import("../props").SpanFunctionString;
+            textAlign?: string;
+            className?: import("../props").RowClassFunctionString;
+            align?: string;
+            prop?: import("../props").LabelFunctionString;
+            index?: number;
+            explain?: boolean | {
+                content: import("../props").LabelFunctionString;
+                head: import("../props").LabelFunctionString;
+            };
+            children?: {
+                label?: import("../props").LabelFunctionString;
+                field?: import("../props").LabelFunctionString;
+                render?: import("../props").RenderFunctionString;
+                disabled?: boolean;
+                renderHead?: import("../props").RenderFunctionString;
+                width?: string | number;
+                minWidth?: string | number;
+                columnKey?: string;
+                showOverflowTooltip?: boolean | {
+                    content: string | ((col: Column, row: Record<string, object>) => string);
+                    disabled?: boolean | ((col: Column, row: Record<string, object>) => boolean);
+                    allowHtml?: boolean;
+                    watchCellResize?: boolean;
+                    mode?: "auto" | "static";
+                    popoverOption?: Record<string, object>;
+                    resizerWay?: import("../props").ResizerWay;
+                    showHead?: boolean;
+                };
+                type?: string;
+                fixed?: string | boolean;
+                resizable?: boolean;
+                sort?: string | boolean | {
+                    sortFn?: (...args: any[]) => number;
+                    sortScope?: import("../props").SortScope;
+                    value?: import("../const").SORT_OPTION;
+                };
+                filter?: string | boolean | {
+                    list: {
+                        label: string;
+                        text?: string;
+                        value: string;
+                        tipKey?: string;
+                    }[];
+                    filterFn?: (...args: any[]) => boolean;
+                    match?: import("../props").FullEnum;
+                    checked?: string[];
+                    filterScope?: import("../props").SortScope;
+                    btnSave?: string | boolean;
+                    btnReset?: string | boolean;
+                    height?: number;
+                    maxHeight?: number;
+                };
+                colspan?: import("../props").SpanFunctionString;
+                rowspan?: import("../props").SpanFunctionString;
+                textAlign?: string;
+                className?: import("../props").RowClassFunctionString;
+                align?: string;
+                prop?: import("../props").LabelFunctionString;
+                index?: number;
+                explain?: boolean | {
+                    content: import("../props").LabelFunctionString;
+                    head: import("../props").LabelFunctionString;
+                };
+                children?: any[];
+                acrossPage?: boolean;
+            }[];
+            acrossPage?: boolean;
+        }[];
+        checked: any[];
+        limit: number;
+        size: string;
+        sizeList: {
+            value?: string;
+            label?: string;
+            height?: number;
+        }[];
+        showLineHeight: boolean;
+        extCls: string;
+        trigger: string;
+        height: number;
+    };
+    renderSettings: () => JSX.Element;
+};
+export type UseSettings = ReturnType<typeof useSettings>;
+export default useSettings;

package/lib/table/{plugins → hooks}/use-shift-key.d.ts

@@ -1,5 +1,5 @@
 import { TablePropTypes } from '../props';
-declare const _default: (props: TablePropTypes) => {
+declare const multiShiftKey: (props: TablePropTypes) => {
     isShiftKeyDown: import("vue").Ref<boolean>;
     setStore: (row: any, index: number) => boolean;
     getStore: () => {
@@ -9,5 +9,7 @@ declare const _default: (props: TablePropTypes) => {
     clearStore: () => void;
     setStoreStart: (row?: any, index?: any) => void;
     clearStoreStart: () => void;
+    removeMultiCheckedEvents: () => void;
 };
-export default _default;
+export type UseMultiShiftKey = ReturnType<typeof multiShiftKey>;
+export default multiShiftKey;