@gx-design-vue/pro-table 0.2.0-alpha.2 → 0.2.0-alpha.21

package/dist/hooks/useRowDrag.js

@@ -0,0 +1,268 @@
+import { arrayMove } from "../utils/arrayMove.js";
+import { flipAnimate } from "../utils/flipAnimate.js";
+import { useAutoScroll } from "./useAutoScroll.js";
+import { nextTick, ref } from "vue";
+import { useEventListener } from "@vueuse/core";
+//#region src/hooks/useRowDrag.ts
+/** 移动阈值（px），超过才视为拖拽，避免误触影响点击 */
+const DRAG_THRESHOLD = 3;
+const SCROLL_RESTORE_FRAMES = 2;
+const DISPLACEMENT_DURATION = 160;
+const DISPLACEMENT_EASING = "cubic-bezier(0.2, 0, 0, 1)";
+const DRAGGING_Z_INDEX = "1000";
+function isFromDragHandle(target) {
+	const el = target;
+	if (!el || typeof el.closest !== "function") return false;
+	const handle = el.closest("[data-drag-handle]");
+	if (!handle) return false;
+	return handle.getAttribute("data-drag-disabled") !== "true";
+}
+/**
+* 表格行拖拽排序 —— 精简复刻 `useTabDrag` 的垂直版本。
+*
+* - 仅从把手列（`[data-drag-handle]`）发起拖拽，单元格交互不受影响
+* - 移动阈值（3px）区分点击与拖拽
+* - 拖拽行 `transform: translateY(delta)` 跟随指针
+* - 同列表其他行按虚拟插入位置实时 `translate` 让位（CSS translate 属性 + WAAPI）
+* - drop 锚点用最近中心法（被拖行中心 Y 与全量各行中心比距离取最近者；含自身，半身位即换位）
+* - 松手 → onSortEnd（仅 emit 排序结果，由使用方回写数据源）→ nextTick 用 flipAnimate 平滑归位
+* - 拖拽结束后捕获抑制下一次 click
+* - 指针接近滚动容器上下边缘时自动滚动（垂直版 detectScrollIntent）
+*/
+function useRowDrag(options) {
+	const { tbodyEl, scrollEl, dataSource, rowKey, rowDraggable, onSortEnd } = options;
+	const isDragging = ref(false);
+	const draggingRowKey = ref("");
+	let dragStartClientY = 0;
+	let dragStartScrollTop = 0;
+	let dragPointerOffsetY = 0;
+	let pointerClientY = 0;
+	let dragEl = null;
+	let rowRects = [];
+	let pendingKey = "";
+	let pendingStartY = 0;
+	let pendingRecord = null;
+	const { scroll: scrollOnDragMove, start: startAutoScroll, stop: stopAutoScroll } = useAutoScroll(scrollEl, () => pointerClientY, { onScroll: updateDragPosition });
+	function queryRowEl(key) {
+		return tbodyEl.value?.querySelector(`tr[data-row-key="${key}"]`) ?? null;
+	}
+	function recordRowRects() {
+		rowRects = [];
+		const data = dataSource.value;
+		for (const record of data) {
+			const key = record?.[rowKey.value];
+			if (key == null) continue;
+			const el = queryRowEl(key);
+			if (!el) continue;
+			const rect = el.getBoundingClientRect();
+			rowRects.push({
+				el,
+				key,
+				top: rect.top,
+				height: rect.height,
+				translate: 0
+			});
+		}
+	}
+	function getCurrentScrollOffset() {
+		return (scrollEl.value?.scrollTop ?? 0) - dragStartScrollTop;
+	}
+	function getVisualPointerY() {
+		return pointerClientY + getCurrentScrollOffset();
+	}
+	function getDragCenterY() {
+		const dragRect = rowRects.find((r) => r.key === draggingRowKey.value);
+		if (!dragRect) return getVisualPointerY();
+		return getVisualPointerY() - dragPointerOffsetY + dragRect.height / 2;
+	}
+	/**
+	* 计算拖拽行应去的目标索引（最近中心法，对齐 dnd-kit `closestCenter`）。
+	*
+	* 在全量行（含拖拽行自身）里找离拖拽行视觉中心最近的行，返回其索引作为
+	* `arrayMove(data, fromIdx, 返回值)` 的 to。返回值的几何意义即"拖拽行想占据的位置"：
+	*  - 最近行是自己(fromIdx) → from===to，不移动
+	*  - 最近行在下方 → 向下移动占据其位置
+	*  - 最近行在上方 → 向上移动占据其位置
+	*
+	* 关键：拖拽行自身必须参与比较，否则切换阈值会从「半个身位」退化成「一个身位」——
+	* 缺少起始参考点后，需要整行越过下一行中心才会换位（表现为完全覆盖才触发）；
+	* 含自身时切换点落在相邻两行中心的中点，即拖动半个行高即换位。
+	*/
+	function computeTargetIdx(dragCenterY) {
+		const fromIdx = rowRects.findIndex((r) => r.key === draggingRowKey.value);
+		if (fromIdx < 0) return -1;
+		let nearestIdx = fromIdx;
+		let nearestDist = Infinity;
+		for (let i = 0; i < rowRects.length; i++) {
+			const center = rowRects[i].top + rowRects[i].height / 2;
+			const dist = Math.abs(dragCenterY - center);
+			if (dist < nearestDist) {
+				nearestDist = dist;
+				nearestIdx = i;
+			}
+		}
+		return nearestIdx;
+	}
+	/** 同区间其他行实时让位 */
+	function applyDisplacement(targetIdx) {
+		const fromIdx = rowRects.findIndex((r) => r.key === draggingRowKey.value);
+		if (fromIdx < 0) return;
+		const dragHeight = rowRects.find((r) => r.key === draggingRowKey.value)?.height ?? 0;
+		for (let i = 0; i < rowRects.length; i++) {
+			const rect = rowRects[i];
+			if (rect.key === draggingRowKey.value) continue;
+			let translate = 0;
+			if (fromIdx < targetIdx && i > fromIdx && i <= targetIdx) translate = -dragHeight;
+			else if (fromIdx > targetIdx && i >= targetIdx && i < fromIdx) translate = dragHeight;
+			applyRowTranslate(rect, translate);
+		}
+	}
+	function applyRowTranslate(rect, nextTranslate) {
+		const prevTranslate = rect.translate;
+		if (prevTranslate === nextTranslate) return;
+		rect.animation?.cancel();
+		rect.translate = nextTranslate;
+		rect.el.style.translate = nextTranslate ? `0px ${nextTranslate}px` : "";
+		if (typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches || typeof rect.el.animate !== "function") return;
+		rect.animation = rect.el.animate({ translate: [`0px ${prevTranslate}px`, `0px ${nextTranslate}px`] }, {
+			duration: DISPLACEMENT_DURATION,
+			easing: DISPLACEMENT_EASING
+		});
+		const clear = () => {
+			rect.animation = void 0;
+		};
+		rect.animation.addEventListener("finish", clear, { once: true });
+		rect.animation.addEventListener("cancel", clear, { once: true });
+	}
+	function updateDragPosition() {
+		if (!isDragging.value) return;
+		if (dragEl) dragEl.style.transform = `translateY(${getVisualPointerY() - dragStartClientY}px)`;
+		applyDisplacement(computeTargetIdx(getDragCenterY()));
+	}
+	function clearInlineStyles(rects = rowRects, activeDragEl = dragEl) {
+		for (const rect of rects) {
+			rect.animation?.cancel();
+			rect.animation = void 0;
+			rect.translate = 0;
+			rect.el.style.translate = "";
+			rect.el.style.zIndex = "";
+		}
+		if (activeDragEl) {
+			activeDragEl.style.transform = "";
+			activeDragEl.classList.remove("row-dragging");
+		}
+	}
+	function restoreScrollTop(scrollTop, frames = SCROLL_RESTORE_FRAMES) {
+		const el = scrollEl.value;
+		if (!el) return;
+		el.scrollTop = scrollTop;
+		if (frames <= 0 || typeof requestAnimationFrame === "undefined") return;
+		requestAnimationFrame(() => restoreScrollTop(scrollTop, frames - 1));
+	}
+	function beginDrag(clientY) {
+		isDragging.value = true;
+		dragStartClientY = clientY;
+		dragStartScrollTop = scrollEl.value?.scrollTop ?? 0;
+		pointerClientY = clientY;
+		dragEl = queryRowEl(draggingRowKey.value);
+		recordRowRects();
+		const dragRect = rowRects.find((r) => r.key === draggingRowKey.value);
+		dragPointerOffsetY = dragRect ? clientY - dragRect.top : 0;
+		if (dragEl) {
+			dragEl.classList.add("row-dragging");
+			dragEl.style.zIndex = DRAGGING_Z_INDEX;
+		}
+		startAutoScroll();
+	}
+	/** 捕获阶段抑制拖拽结束后的下一次 click */
+	function suppressNextClick() {
+		const target = dragEl;
+		if (!target) return;
+		const suppress = (event) => {
+			event.stopPropagation();
+			event.preventDefault();
+			target.removeEventListener("click", suppress, true);
+		};
+		target.addEventListener("click", suppress, {
+			capture: true,
+			once: true
+		});
+	}
+	function handleMousedown(event, record) {
+		if (event.button !== 0) return;
+		if (!isFromDragHandle(event.target)) return;
+		const cfg = rowDraggable.value;
+		if (!cfg) return;
+		if ((typeof cfg === "object" ? cfg : {}).disabled?.(record)) return;
+		event.preventDefault();
+		const key = record?.[rowKey.value];
+		pendingKey = key;
+		pendingStartY = event.clientY;
+		pendingRecord = record;
+		draggingRowKey.value = key;
+	}
+	function handleMousemove(event) {
+		if (!isDragging.value) {
+			if (!pendingKey) return;
+			if (Math.abs(event.clientY - pendingStartY) < DRAG_THRESHOLD) return;
+			beginDrag(pendingStartY);
+		}
+		pointerClientY = event.clientY;
+		updateDragPosition();
+		scrollOnDragMove();
+	}
+	function endDrag() {
+		const targetIdx = computeTargetIdx(getDragCenterY());
+		const fromIdx = rowRects.findIndex((r) => r.key === draggingRowKey.value);
+		const data = dataSource.value;
+		const prevRects = /* @__PURE__ */ new Map();
+		for (const { key, el } of rowRects) prevRects.set(key, el.getBoundingClientRect());
+		stopAutoScroll();
+		const currentRowRects = rowRects;
+		const currentDragEl = dragEl;
+		const currentScrollTop = scrollEl.value?.scrollTop ?? 0;
+		const record = pendingRecord;
+		if (targetIdx >= 0 && targetIdx !== fromIdx && targetIdx < data.length) {
+			const newData = arrayMove(data, fromIdx, targetIdx);
+			onSortEnd?.(fromIdx, targetIdx, newData, record);
+			nextTick(() => {
+				restoreScrollTop(currentScrollTop);
+				clearInlineStyles(currentRowRects, currentDragEl);
+				flipAnimate(data.map((r) => ({
+					key: r[rowKey.value],
+					el: queryRowEl(r[rowKey.value])
+				})).filter((entry) => Boolean(entry.el)), prevRects);
+				restoreScrollTop(currentScrollTop);
+			});
+		} else clearInlineStyles();
+		suppressNextClick();
+		isDragging.value = false;
+		draggingRowKey.value = "";
+		dragEl = null;
+		rowRects = [];
+		dragPointerOffsetY = 0;
+		pendingKey = "";
+		pendingRecord = null;
+	}
+	function handleMouseup() {
+		if (isDragging.value) endDrag();
+		else if (pendingKey) {
+			pendingKey = "";
+			draggingRowKey.value = "";
+			pendingRecord = null;
+		}
+	}
+	const documentTarget = typeof document === "undefined" ? void 0 : document;
+	useEventListener(documentTarget, "mousemove", handleMousemove);
+	useEventListener(documentTarget, "mouseup", handleMouseup);
+	function getRowProps(record, _index) {
+		return { onMousedown: (event) => handleMousedown(event, record) };
+	}
+	return {
+		isDragging,
+		draggingRowKey,
+		getRowProps
+	};
+}
+//#endregion
+export { useRowDrag };

package/dist/hooks/useRowSelection.d.ts

@@ -1,19 +1,31 @@
-import { ProTableRowSelection } from "../types/TableTypings.js";
-import { Ref } from "vue";
+import { ComputedRef } from "vue";
 import { RecordType } from "@gx-design-vue/pro-utils";
-import { SelectionSelectFn } from "ant-design-vue/es/table/interface";
-import { Key } from "ant-design-vue/es/vc-table/interface";
+import { Key, TableRowSelection } from "antdv-next/dist/table/interface";
 
 //#region src/hooks/useRowSelection.d.ts
-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: RecordType[]) => void;
-  clearAllRowKeys: () => void;
-};
+interface UseRowSelectionOptions<T = RecordType> {
+  rowKey: ComputedRef<string>;
+  rowSelection: ComputedRef<TableRowSelection<T> | undefined>;
+  dataSource: ComputedRef<T[]>;
+}
+interface UseRowSelectionReturn<T = RecordType> {
+  selectedRowKeys: ComputedRef<Key[]>;
+  selectedItems: ComputedRef<T[]>;
+  mergedRowSelection: ComputedRef<TableRowSelection<T> | undefined>;
+  select: (record: T, selected: boolean) => void;
+  selectAll: (records: T[], selected: boolean) => void;
+  remove: (keys: Key[]) => void;
+  clear: () => void;
+  sync: () => void;
+}
+/**
+ * 行选择状态管理。内部使用 reactive Map 作为唯一数据源，
+ * selectedRowKeys / selectedItems 均从 Map 派生，保证 keys 与 items 永远同步。
+ *
+ * antdv-next 已废弃 onSelectAll / onSelectInvert / onSelectNone，
+ * 所有选中变化统一通过 onChange 回调，因此 mergedRowSelection 只拦截 onChange，
+ * 不拦截 onSelect / onSelectAll。
+ */
+declare function useRowSelection<T = RecordType>(options: UseRowSelectionOptions<T>): UseRowSelectionReturn<T>;
 //#endregion
-export { useRowSelection };
+export { UseRowSelectionOptions, UseRowSelectionReturn, useRowSelection };

package/dist/hooks/useRowSelection.js

@@ -1,89 +1,102 @@
-import { ref, watch } from "vue";
-import { arrayUnique, cloneDeep } from "@gx-design-vue/pro-utils";
-
+import { computed, onScopeDispose, reactive, watch } from "vue";
 //#region src/hooks/useRowSelection.ts
-function useRowSelection(rowKey, rowSelection) {
-	const selectedKeys = ref([]);
-	const selectedItems = ref([]);
-	watch(() => rowSelection.value?.selectedRows, (keys) => {
-		selectedItems.value = cloneDeep(keys || []);
-	}, {
-		deep: true,
-		immediate: true
-	});
-	watch(() => rowSelection.value?.selectedRowKeys, (keys) => {
-		selectedKeys.value = arrayUnique([...keys || []]);
-	}, {
-		deep: true,
-		immediate: true
-	});
-	const selectRowKey = (record, selected) => {
-		const type = rowSelection.value?.type || "checkbox";
-		if (rowKey.value) if (selected) if (record?.[rowKey.value] && type === "checkbox") {
-			selectedKeys.value.push(record[rowKey.value]);
-			selectedItems.value.push(record);
-		} else {
-			selectedKeys.value = [record[rowKey.value]];
-			selectedItems.value = [record];
+function getKey(record, rowKey) {
+	return record[rowKey];
+}
+/**
+* 行选择状态管理。内部使用 reactive Map 作为唯一数据源，
+* selectedRowKeys / selectedItems 均从 Map 派生，保证 keys 与 items 永远同步。
+*
+* antdv-next 已废弃 onSelectAll / onSelectInvert / onSelectNone，
+* 所有选中变化统一通过 onChange 回调，因此 mergedRowSelection 只拦截 onChange，
+* 不拦截 onSelect / onSelectAll。
+*/
+function useRowSelection(options) {
+	const selectedMap = reactive(/* @__PURE__ */ new Map());
+	const stopWatch = watch(() => options.rowSelection.value?.selectedRowKeys, (keys) => {
+		if (!keys) return;
+		const newMap = /* @__PURE__ */ new Map();
+		const currentDataSource = options.dataSource.value;
+		for (const key of keys) {
+			const existing = selectedMap.get(key);
+			const matched = currentDataSource.find((record) => getKey(record, options.rowKey.value) === key);
+			newMap.set(key, matched ?? existing);
 		}
-		else {
-			selectedKeys.value = selectedKeys.value.filter((item) => item !== record[rowKey.value]);
-			selectedItems.value = selectedItems.value.filter((item) => item[rowKey.value] !== record[rowKey.value]);
+		selectedMap.clear();
+		for (const [key, item] of newMap) selectedMap.set(key, item);
+	}, { immediate: true });
+	onScopeDispose(() => stopWatch());
+	const selectedRowKeys = computed(() => Array.from(selectedMap.keys()));
+	const selectedItems = computed(() => Array.from(selectedMap.values()).filter((item) => item != null));
+	function emitChange(type) {
+		options.rowSelection.value?.onChange?.(selectedRowKeys.value, selectedItems.value, { type });
+	}
+	function select(record, selected) {
+		const key = getKey(record, options.rowKey.value);
+		const selectionType = options.rowSelection.value?.type ?? "checkbox";
+		if (selected) if (selectionType === "radio") {
+			selectedMap.clear();
+			selectedMap.set(key, record);
+		} else selectedMap.set(key, record);
+		else selectedMap.delete(key);
+		emitChange(selected ? selectionType === "radio" ? "single" : "multiple" : "none");
+	}
+	function selectAll(records, selected) {
+		if (selected) for (const record of records) selectedMap.set(getKey(record, options.rowKey.value), record);
+		else for (const record of records) selectedMap.delete(getKey(record, options.rowKey.value));
+		emitChange(selected ? "all" : "none");
+	}
+	function remove(keys) {
+		for (const key of keys) selectedMap.delete(key);
+		emitChange("none");
+	}
+	function clear() {
+		selectedMap.clear();
+		emitChange("none");
+	}
+	/** 从当前 dataSource 补全 Map 中 value 为空的条目（分页切换后调用） */
+	function sync() {
+		const currentDataSource = options.dataSource.value;
+		const rowKeyField = options.rowKey.value;
+		for (const [key, item] of selectedMap) if (item == null) {
+			const matched = currentDataSource.find((record) => getKey(record, rowKeyField) === key);
+			if (matched) selectedMap.set(key, matched);
 		}
-	};
-	const changeRowKey = () => {
-		if (rowSelection.value) rowSelection.value?.onChange?.(selectedKeys.value, selectedItems.value);
-	};
-	const selectAllRowKey = (selected, selectedRows, changeRows) => {
-		if (rowKey.value) if (selected) selectedRows.map((item) => {
-			if (selectedKeys.value.every((el) => el !== item?.[rowKey.value])) {
-				if (item?.[rowKey.value]) {
-					selectedKeys.value.push(item[rowKey.value]);
-					selectedItems.value.push(item);
-				}
-			}
-			return item;
-		});
-		else changeRows.map((item) => {
-			if (selectedKeys.value.includes(item?.[rowKey.value])) {
-				selectedKeys.value = selectedKeys.value.filter((el) => el !== item[rowKey.value]);
-				selectedItems.value = selectedItems.value.filter((el) => el[rowKey.value] !== item[rowKey.value]);
-			}
-			return item;
-		});
-	};
-	const removeRowKeys = (keys) => {
-		selectedKeys.value = selectedKeys.value.filter((el) => !keys.includes(el));
-		selectedItems.value = selectedItems.value.filter((el) => !keys.includes(el?.[rowKey.value || ""]));
-		changeRowKey();
-	};
-	const syncSelectedRows = (dataList) => {
-		if (rowKey.value) {
-			if (selectedKeys.value.length !== selectedItems.value.length) {
-				const itemsKeys = selectedItems.value.map((item) => item[rowKey.value]);
-				const notIncludes = selectedKeys.value.filter((item) => !itemsKeys.includes(item));
-				dataList.forEach((item) => {
-					if (notIncludes.includes(item[rowKey.value])) selectedItems.value.push(cloneDeep(item));
-				});
-			}
+	}
+	/**
+	* 处理 antdv Table 的 onChange 回调。
+	* antd 传入的 rows 只包含当前页数据，需与已有 Map 合并以保留跨页选中项。
+	*/
+	function handleAntdChange(keys, rows, info) {
+		const rowKeyField = options.rowKey.value;
+		const newMap = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const fromRows = rows.find((record) => getKey(record, rowKeyField) === key);
+			const existing = selectedMap.get(key);
+			newMap.set(key, fromRows ?? existing);
 		}
-	};
-	const clearAllRowKeys = () => {
-		selectedKeys.value = [];
-		selectedItems.value = [];
-		changeRowKey();
-	};
+		selectedMap.clear();
+		for (const [key, item] of newMap) selectedMap.set(key, item);
+		options.rowSelection.value?.onChange?.(selectedRowKeys.value, selectedItems.value, info);
+	}
 	return {
-		selectedKeys,
+		selectedRowKeys,
 		selectedItems,
-		selectRowKey,
-		selectAllRowKey,
-		removeRowKeys,
-		changeRowKey,
-		syncSelectedRows,
-		clearAllRowKeys
+		mergedRowSelection: computed(() => {
+			const rowSelectionConfig = options.rowSelection.value;
+			if (!rowSelectionConfig) return void 0;
+			return {
+				...rowSelectionConfig,
+				selectedRowKeys: selectedRowKeys.value,
+				onChange: handleAntdChange
+			};
+		}),
+		select,
+		selectAll,
+		remove,
+		clear,
+		sync
 	};
 }
-
 //#endregion
-export { useRowSelection };
+export { useRowSelection };

package/dist/hooks/useTable.d.ts

@@ -1,90 +1,48 @@
-import { ProColumnType, ProColumnsType, ProSearchMap } from "../types/ColumnTypings.js";
-import { ProCoreActionType, ProCoreFormType, ProTableProps, ProTableRef, ProTableRowSelection, RequestConfig, RequestFunction } from "../types/TableTypings.js";
-import { BaseTableProps } from "../props.js";
+import { PageState, ProCoreActionType, ProCoreFormType, ProSearchMap, ProTablePaginationConfig, ProTableProps, ProTableRef, RequestFunction, RowSelectionActions } from "../interface.js";
 import { ComputedRef, MaybeRef, Reactive, Ref } from "vue";
-import { RecordType } from "@gx-design-vue/pro-utils";
+import { FilterValue, SorterResult, TableCurrentDataSource } from "antdv-next/dist/table/interface";
 
 //#region src/hooks/useTable.d.ts
-type ProTableState<T extends object = RecordType, R extends object = RecordType> = Omit<BaseTableProps, 'columns' | 'params' | 'dataSource' | 'rowSelection' | 'searchMap' | 'rowKey' | 'postData' | 'onReset' | 'onReload' | 'onSubmit' | 'onExpand' | 'title' | 'footer' | 'rowExpandable' | 'transformCellText' | 'expandIcon' | 'rowClassName' | 'customRow' | 'customHeaderRow' | 'expandedRowRender' | 'onBeforeSearchSubmit'> & {
-  params: R;
-  columns: ProColumnsType<T, R>;
-  dataSource: T[];
-  rowSelection: ProTableRowSelection<T>;
-  searchMap: ProSearchMap<undefined, keyof R | keyof T>[];
-  rowKey?: keyof T;
-  title?: (data: T[]) => any;
-  footer?: (data: T[]) => any;
-  postData?: (data: T[]) => any;
-  rowExpandable?: (record: T) => boolean;
-  transformCellText?: (opt: {
-    text: any;
-    column: ProColumnType<T, R>;
-    record: any;
-    index: number;
-  }) => any;
-  expandIcon?: (props: {
-    prefixCls: string;
-    expanded: boolean;
-    record: T;
-    expandable: boolean;
-    onExpand: (record: T, event: MouseEvent) => void;
-  }) => any;
-  customRow?: (data: T, index?: number, column?: ProColumnType<T, R>) => any;
-  customHeaderRow?: (data: T, index?: number, column?: ProColumnType<T, R>) => any;
-  expandedRowRender: (opt: {
-    record: T;
-    index: number;
-    indent: number;
-    expanded: boolean;
-  }) => any;
-  rowClassName?: string | ((record: T, index: number, indent: number) => string);
-  onReset?: (params?: Partial<R>) => void;
-  onReload?: (params?: Partial<R>) => void;
-  onSubmit?: (params?: Partial<R>) => void;
-  onExpand?: (expanded: boolean, record: T) => void;
-  onResizeColumn?: (w: number, col: ProColumnType<T, R>) => void;
-  onBeforeSearchSubmit?: RequestFunction<T, R>;
-};
-type BaseTableState<T extends object = RecordType, R extends object = RecordType> = Omit<ProTableProps<T, R>, 'request'>;
-interface UseTableReturn<T extends object = RecordType, R extends object = RecordType> {
-  /** @name loading 状态，可以直接进行修改 */
+interface UseTableOptions<T = any, R = any> {
+  state?: MaybeRef<Partial<ProTableProps<T, R>>> | Reactive<Partial<ProTableProps<T, R>>>;
+  request?: RequestFunction<T, R>;
+}
+interface UseTableReturn<T = any, R = any> {
+  /** 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 主动刷新，按照当前的参数在当前页重新请求下 */
+  /** 表格请求参数（含分页 + 表单搜索参数） */
+  requestSearch: ComputedRef<Partial<R> & Partial<PageState>>;
+  /** 表格行选择 keys */
+  selectedKeys: ComputedRef<(string | number)[]>;
+  /** 表格行选择 rows */
+  selectedItems: ComputedRef<T[]>;
+  /** 表格行选择操作 */
+  rowsSelection: RowSelectionActions<T>;
+  /** action 表格实例 */
+  actionRef: ComputedRef<ProCoreActionType<T, R>>;
+  /** form 查询表单实例 */
+  formRef: ComputedRef<ProCoreFormType<R>>;
+  /** 主动刷新 */
   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 设置翻页 */
+  /** 设置翻页、排序、筛选并刷新 */
+  setPageInfo: (pagination: ProTablePaginationConfig, filters?: Record<string, FilterValue | null>, sorter?: SorterResult | SorterResult[], extra?: TableCurrentDataSource) => void;
+  /** 设置翻页 */
   setPagination: ProCoreActionType<T, R>['setPagination'];
-  /** @name 刷新并清空表单，重置为第一页 */
+  /** 刷新并清空表单，重置为第一页 */
   reloadAndReset: ProCoreActionType<T, R>['reloadAndReset'];
-  /** @name 改变loading状态 */
+  /** 改变 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<ProSearchMap<any>>) => void;
+  /** 表格参数，传递给 ProTable 组件 */
+  tableState: Reactive<Partial<ProTableProps<T, R>>>;
+  /** 更新 searchMap 中指定字段的配置 */
+  updateSearchMap: (key: keyof T | keyof R, value: Partial<ProSearchMap<any>>) => void;
 }
-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>;
+declare function useTable<T = any, R = any>(tableRef: Ref<ProTableRef<T, R> | undefined>, options?: UseTableOptions<T, R>): UseTableReturn<T, R>;
 //#endregion
-export { BaseTableState, ProTableState, UseTableReturn, useTable };
+export { UseTableOptions, UseTableReturn, useTable };