@gx-design-vue/pro-table 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/hooks/usePagination.js

@@ -1,10 +1,9 @@
-import { reactive, ref, unref, watch } from "vue";
-import { cloneDeep, deepMerge, forInObject, isFunction, isNumber } from "@gx-design-vue/pro-utils";
-//#region src/hooks/usePagination.tsx
+import { computed, reactive, ref, watch } from "vue";
+import { isNumber, merge } from "@gx-design-vue/pro-utils";
+//#region src/hooks/usePagination.ts
 const defaultPagination = {
 	current: 1,
 	pageSize: 10,
-	size: "default",
 	showQuickJumper: true,
 	showSizeChanger: true,
 	pageSizeOptions: [
@@ -14,44 +13,56 @@ const defaultPagination = {
 		"100"
 	]
 };
-function usePagination({ pagination, pageItemRender }) {
+/**
+* 分页状态管理。
+* 合并用户分页配置与默认值，分离 UI 分页展示与请求分页参数。
+* setPagination 只同步 current/pageSize/total 到 requestPagination，避免 UI 字段污染请求参数。
+*/
+function usePagination({ pagination }) {
 	const paginationInfo = ref({ ...defaultPagination });
 	const requestPagination = reactive({
-		current: defaultPagination.current || 1,
-		pageSize: defaultPagination.pageSize || 10,
+		current: defaultPagination.current,
+		pageSize: defaultPagination.pageSize,
 		total: 0
 	});
-	watch(() => pagination.value, () => {
-		if (pagination.value === false) {
+	watch(() => pagination.value, (paginationValue) => {
+		if (paginationValue === false) {
 			paginationInfo.value = false;
 			return;
 		}
-		const itemRenderProps = isFunction(pageItemRender) ? { itemRender: ({ page, type, originalElement }) => pageItemRender ? pageItemRender({
-			page,
-			type,
-			originalElement
-		}) : null } : null;
-		const pageInfo = {
+		const merged = {
 			...defaultPagination,
-			...pagination.value || {},
-			...itemRenderProps || {}
+			...paginationValue || {}
 		};
-		if (!pagination.value?.showTotal) pageInfo.showTotal = (total) => `共${total < pageInfo.pageSize ? 1 : Math.ceil(total / (pageInfo.pageSize || 10))}页 ${total}条记录`;
-		paginationInfo.value = cloneDeep(pageInfo);
-		forInObject(requestPagination, (key) => {
-			if (isNumber(pageInfo[key])) requestPagination[key] = pageInfo[key];
-		});
+		paginationInfo.value = merged;
+		syncRequestPagination(merged);
 	}, {
-		deep: 1,
+		deep: true,
 		immediate: true
 	});
-	function setPagination(state) {
+	function syncRequestPagination(info) {
+		if (isNumber(info.current)) requestPagination.current = info.current;
+		if (isNumber(info.pageSize)) requestPagination.pageSize = info.pageSize;
+		if (isNumber(info.total)) requestPagination.total = info.total;
+	}
+	function setPagination(info) {
 		if (paginationInfo.value === false) return;
-		paginationInfo.value = deepMerge(unref(paginationInfo), state);
-		for (const key in requestPagination) if (state[key] && isNumber(state[key])) requestPagination[key] = state[key];
+		paginationInfo.value = merge({}, paginationInfo.value, info);
+		syncRequestPagination(info);
 	}
 	return {
 		paginationInfo,
+		paginationAlign: computed(() => {
+			const paginationConfig = paginationInfo.value;
+			if (!paginationConfig) return "end";
+			const placementList = paginationConfig.placement;
+			if (!Array.isArray(placementList)) return "end";
+			const matchedPlacement = placementList.find((item) => item.includes("bottom") || item.includes("top"));
+			if (!matchedPlacement) return "end";
+			if (matchedPlacement.includes("Start")) return "start";
+			if (matchedPlacement.includes("Center")) return "center";
+			return "end";
+		}),
 		requestPagination,
 		setPagination
 	};

package/dist/hooks/useRequestOptions.d.ts

@@ -0,0 +1,18 @@
+import { ProSchemaValueEnumType } from "../interface.js";
+import { Ref } from "vue";
+
+//#region src/hooks/useRequestOptions.d.ts
+interface UseRequestOptionsParams {
+  fetch?: () => Promise<ProSchemaValueEnumType[]>;
+  manual?: boolean;
+  debounceTime?: number;
+}
+interface UseRequestOptionsReturn {
+  optionList: Ref<ProSchemaValueEnumType[]>;
+  loading: Ref<boolean>;
+  status: Ref<'idle' | 'loading' | 'success' | 'error'>;
+  fetchOptions: () => Promise<ProSchemaValueEnumType[] | undefined>;
+}
+declare function useRequestOptions(params: UseRequestOptionsParams): UseRequestOptionsReturn;
+//#endregion
+export { UseRequestOptionsParams, UseRequestOptionsReturn, useRequestOptions };

package/dist/hooks/useRequestOptions.js

@@ -0,0 +1,39 @@
+import { onUnmounted, ref } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+//#region src/hooks/useRequestOptions.ts
+function useRequestOptions(params) {
+	const optionList = ref([]);
+	const loading = ref(false);
+	const status = ref("idle");
+	const debouncedFetch = useDebounceFn(async () => {
+		if (!params.fetch) return;
+		loading.value = true;
+		status.value = "loading";
+		try {
+			const result = await params.fetch();
+			optionList.value = result ?? [];
+			status.value = "success";
+			return result;
+		} catch (error) {
+			console.error("[useRequestOptions] fetch error:", error);
+			status.value = "error";
+			optionList.value = [];
+			return;
+		} finally {
+			loading.value = false;
+		}
+	}, params.debounceTime ?? 10);
+	if (params.fetch && !params.manual) debouncedFetch();
+	onUnmounted(() => {
+		optionList.value = [];
+		loading.value = false;
+	});
+	return {
+		optionList,
+		loading,
+		status,
+		fetchOptions: debouncedFetch
+	};
+}
+//#endregion
+export { useRequestOptions };

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,86 +1,101 @@
-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

package/dist/hooks/useTable.d.ts

@@ -1,90 +1,32 @@
-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, 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: 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>>;
+  selectedKeys: ComputedRef<(string | number)[]>;
+  selectedItems: ComputedRef<T[]>;
+  rowsSelection: RowSelectionActions<T>;
   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状态 */
   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;
+  tableState: Reactive<Partial<ProTableProps<T, R>>>;
 }
-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>;
+/**
+ * 外部命令式 hook，通过 template ref 访问 ProTable 暴露的 actionRef。
+ * loading 单向同步（actionRef → 外部 state），避免双向 watch 循环。
+ */
+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 };

package/dist/hooks/useTable.js

@@ -1,70 +1,82 @@
-import { computed, isRef, reactive, ref, watch } from "vue";
-import { cloneDeep, deepMerge, isObject, useDeepMerge } from "@gx-design-vue/pro-utils";
+import { computed, reactive, ref, toValue, watch } from "vue";
+import { merge } from "@gx-design-vue/pro-utils";
 //#region src/hooks/useTable.ts
+const EMPTY_ARRAY = [];
+/**
+* 外部命令式 hook，通过 template ref 访问 ProTable 暴露的 actionRef。
+* loading 单向同步（actionRef → 外部 state），避免双向 watch 循环。
+*/
 function useTable(tableRef, options) {
-	function getTableState() {
-		const defaultState = {
-			params: {},
-			searchMap: []
-		};
-		if (options?.state) {
-			if (isRef(options.state) && isObject(options.state.value)) return deepMerge(defaultState, cloneDeep(options.state.value));
-			else if (isObject(options.state) && !isRef(options.state)) return deepMerge(defaultState, cloneDeep(options.state));
+	const tableState = reactive({});
+	const syncedStateKeys = /* @__PURE__ */ new Set();
+	function syncTableState(state = {}) {
+		const nextState = merge({}, state);
+		for (const key of syncedStateKeys) if (!(key in nextState)) {
+			delete tableState[key];
+			syncedStateKeys.delete(key);
 		}
-		return defaultState;
+		Object.assign(tableState, nextState);
+		for (const key of Object.keys(nextState)) syncedStateKeys.add(key);
+		if (options?.request) tableState.request = options.request;
 	}
-	const tableState = reactive(deepMerge(getTableState(), { request: options?.request }));
-	if (options?.state) watch(() => options.state && isRef(options.state) ? options.state.value : options.state, () => {
-		updateTableState();
-	}, { deep: true });
-	const actionRef = computed(() => {
-		if (tableRef.value) return tableRef.value.actionRef();
-		return {};
-	});
-	const formRef = computed(() => {
-		if (tableRef.value?.formRef) return tableRef.value.formRef();
-		return {};
+	watch(() => toValue(options?.state), (newState) => {
+		syncTableState(newState ?? {});
+	}, {
+		deep: true,
+		immediate: true
 	});
-	const requestSearch = computed(() => {
-		return {
-			...actionRef.value?.pageInfo || {},
-			...formRef.value?.getFormSearch?.() || {}
-		};
+	const actionRef = computed(() => {
+		return tableRef.value?.actionRef?.() ?? {};
 	});
-	const loading = ref(!!actionRef.value?.loading?.value);
+	const requestSearch = computed(() => ({ ...actionRef.value?.pageInfo || {} }));
+	const loading = ref(false);
 	watch(() => actionRef.value?.loading?.value, (val) => {
 		loading.value = !!val;
 	});
-	watch(loading, (val) => {
-		actionRef.value?.setLoading?.(!!val);
-	});
-	function updateTableState() {
-		useDeepMerge(tableState, getTableState());
+	function reload(info) {
+		actionRef.value?.reload?.(info);
+	}
+	function setTableDataList(data) {
+		actionRef.value?.setTableDataList?.(data);
+	}
+	function operateTableDataRow(props) {
+		actionRef.value?.operateTableDataRow?.(props);
 	}
-	function updateSearchMap(key, value) {
-		if (tableState.searchMap) tableState.searchMap = cloneDeep(tableState.searchMap).map((item) => {
-			if (item.name === key) return deepMerge(item, value);
-			return item;
-		});
+	function setPageInfo(pagination, filters, sorter, extra) {
+		actionRef.value?.setPageInfo?.(pagination, filters, sorter, extra);
 	}
+	function setPagination(pagination) {
+		actionRef.value?.setPagination?.(pagination);
+	}
+	function reloadAndReset(options) {
+		actionRef.value?.reloadAndReset?.(options);
+	}
+	function setLoading(value) {
+		loading.value = value;
+	}
+	const selectedKeys = computed(() => actionRef.value?.selectedKeys?.value ?? []);
+	const selectedItems = computed(() => actionRef.value?.selectedItems?.value ?? []);
 	return {
-		formRef,
-		actionRef,
-		tableState,
-		requestSearch,
 		loading,
-		dataSource: computed(() => actionRef?.value?.dataSource?.value || []),
-		selectedKeys: computed(() => actionRef?.value?.selectedKeys?.value || []),
-		selectedItems: computed(() => actionRef?.value?.selectedItems?.value || []),
-		rowsSelection: actionRef?.value?.rowsSelection,
-		setTableDataList: (data) => actionRef.value?.setTableDataList?.(data),
-		reloadAndReset: (options) => actionRef.value?.reloadAndReset?.(options),
-		setPageInfo: (pagination, filters, sorter, extra) => actionRef.value?.setPageInfo?.(pagination, filters, sorter, extra),
-		setPagination: (pageInfo) => actionRef.value?.setPagination?.(pageInfo),
-		setLoading: (value) => loading.value = value,
-		operateTableDataRow: (params) => actionRef.value?.operateTableDataRow?.(params),
-		reload: (info) => actionRef.value?.reload?.(info),
-		updateSearchMap
+		dataSource: computed(() => actionRef.value?.dataSource?.value ?? EMPTY_ARRAY),
+		requestSearch,
+		selectedKeys,
+		selectedItems,
+		rowsSelection: {
+			clear: () => actionRef.value?.rowsSelection?.clear?.(),
+			select: (record, selected) => actionRef.value?.rowsSelection?.select?.(record, selected),
+			selectAll: (records, selected) => actionRef.value?.rowsSelection?.selectAll?.(records, selected),
+			remove: (keys) => actionRef.value?.rowsSelection?.remove?.(keys),
+			sync: () => actionRef.value?.rowsSelection?.sync?.()
+		},
+		reload,
+		setTableDataList,
+		operateTableDataRow,
+		setPageInfo,
+		setPagination,
+		reloadAndReset,
+		setLoading,
+		tableState
 	};
 }
 //#endregion