@antdv-vue/pro-table 0.0.0-stage → 2.0.3

package/dist/utils/genProColumnsToColumns.d.ts

@@ -0,0 +1,69 @@
+import { ContainerReturnType } from "../Store/Provide.js";
+import { FilterValue as FilterValue$1, ProColumnType, ProColumns, ProSorter } from "../typing.js";
+import { ParamsType } from "@antdv-vue/pro-provider";
+import { Key, ProFieldValueObjectType, ProFieldValueType, ProSchemaComponentTypes, UseEditableUtilType } from "@antdv-vue/pro-utils";
+import { TableProps } from "antdv-next";
+import { ProFieldEmptyText } from "@antdv-vue/pro-field";
+import { SortOrder } from "antdv-next/dist/table/index";
+
+//#region src/utils/genProColumnsToColumns.d.ts
+type ResizeWidthMap = Record<string, number>;
+type ColumnToColumnParams<T, U, ValueType> = {
+  columns?: ProColumns<T, ValueType>[];
+  counter?: ContainerReturnType<T, U, ValueType>;
+  columnEmptyText?: ProFieldEmptyText;
+  type?: ProSchemaComponentTypes;
+  marginSM: number;
+  editableUtils?: UseEditableUtilType<T>;
+  childrenColumnName?: string;
+  proFilter?: Record<string, FilterValue$1>;
+  proSort?: Record<string, SortOrder>;
+  columnResizeWidthMap?: ResizeWidthMap;
+} & Partial<Pick<TableProps<T>, 'rowKey'>>;
+/**
+ * 根据 key 和 dataIndex 生成唯一 id
+ *
+ * @param key 用户设置的 key
+ * @param index 序列号，理论上唯一
+ */
+declare function genColumnKey<T>(key?: T, index?: Key): string;
+/**
+ * 将 ProTable - column - dataIndex 转为字符串形式
+ *
+ * @param dataIndex Column 中的 dataIndex
+ */
+declare function parseDataIndex<T, K>(dataIndex: ProColumnType<T, K>['dataIndex']): string | undefined;
+/**
+ * 判断是否为本地筛选
+ * @param filters 筛选配置
+ * @param onFilter 筛选函数
+ * @returns 是否为本地筛选
+ */
+declare function isLocalFilter<T, K>(filters: ProColumnType<T, K>['filters'], onFilter: ProColumnType<T, K>['onFilter']): boolean;
+/**
+ * 判断是否为本地排序
+ * @param sorter 排序配置
+ * @returns 是否为本地排序
+ */
+declare function isLocalSorter<T>(sorter: ProSorter<T>): boolean;
+/**
+ * 解析对应排序值，用作双向绑定
+ * @param proSort 排序配置
+ * @param columnProps 列配置
+ * @returns 排序值
+ */
+declare function parseProSortOrder<T, K>(proSort?: Record<string, SortOrder>, columnProps?: ProColumnType<T, K>): SortOrder | undefined;
+/**
+ * 解析对应筛选值，用作双向绑定
+ * @param proFilter 筛选配置
+ * @param columnProps 列配置
+ * @returns 筛选值
+ */
+declare function parseProFilteredValue<T, K>(proFilter?: Record<string, FilterValue$1>, columnProps?: ProColumnType<T, K>): FilterValue$1 | undefined;
+/**
+ * 转化 columns 到 pro 的格式 主要是 render 方法的自行实现
+ *
+ */
+declare function genProColumnsToColumns<T extends Record<string, any>, U extends ParamsType, ValueType extends (ProFieldValueType | ProFieldValueObjectType)>(params: ColumnToColumnParams<T, U, ValueType>, parents?: ProColumns<T, any>): ProColumns<T, ValueType>[] | undefined;
+//#endregion
+export { genColumnKey, genProColumnsToColumns, isLocalFilter, isLocalSorter, parseDataIndex, parseProFilteredValue, parseProSortOrder };

package/dist/utils/genProColumnsToColumns.js

@@ -0,0 +1,197 @@
+import columnRender, { defaultOnFilter, renderColumnsTitle } from "./columnRender.js";
+import { shallowReactive } from "vue";
+import { omitBoolean, omitUndefinedAndEmptyArr, runFunction } from "@antdv-vue/pro-utils";
+import { Table } from "antdv-next";
+import { proFieldParsingValueEnumToArray } from "@antdv-vue/pro-field";
+//#region src/utils/genProColumnsToColumns.ts
+const columnResizeWidthMaps = /* @__PURE__ */ new WeakMap();
+function getColumnResizeWidthMap(columns, inheritedMap) {
+	if (inheritedMap) return inheritedMap;
+	if (!columns) return shallowReactive({});
+	const existingMap = columnResizeWidthMaps.get(columns);
+	if (existingMap) return existingMap;
+	const nextMap = shallowReactive({});
+	columnResizeWidthMaps.set(columns, nextMap);
+	return nextMap;
+}
+/**
+* 根据 key 和 dataIndex 生成唯一 id
+*
+* @param key 用户设置的 key
+* @param index 序列号，理论上唯一
+*/
+function genColumnKey(key, index) {
+	if (key) return Array.isArray(key) ? key.join("-") : key.toString();
+	return `${index}`;
+}
+/**
+* 将 ProTable - column - dataIndex 转为字符串形式
+*
+* @param dataIndex Column 中的 dataIndex
+*/
+function parseDataIndex(dataIndex) {
+	if (Array.isArray(dataIndex)) return dataIndex.join(",");
+	return dataIndex?.toString();
+}
+/**
+* 判断是否为本地筛选
+* @param filters 筛选配置
+* @param onFilter 筛选函数
+* @returns 是否为本地筛选
+*/
+function isLocalFilter(filters, onFilter) {
+	return !!filters && !!onFilter;
+}
+/**
+* 判断是否为本地排序
+* @param sorter 排序配置
+* @returns 是否为本地排序
+*/
+function isLocalSorter(sorter) {
+	return typeof sorter === "function" || typeof sorter === "object" && typeof sorter.compare === "function";
+}
+/**
+* 解析对应排序值，用作双向绑定
+* @param proSort 排序配置
+* @param columnProps 列配置
+* @returns 排序值
+*/
+function parseProSortOrder(proSort, columnProps) {
+	const { sorter, sortOrder: columnSortOrder, dataIndex } = columnProps || {};
+	if (columnSortOrder !== void 0) return columnSortOrder;
+	if (sorter == null) return void 0;
+	if (isLocalSorter(sorter)) return void 0;
+	const sortKey = typeof sorter === "string" ? sorter : parseDataIndex(dataIndex);
+	return sortKey ? proSort?.[sortKey] : void 0;
+}
+/**
+* 解析对应筛选值，用作双向绑定
+* @param proFilter 筛选配置
+* @param columnProps 列配置
+* @returns 筛选值
+*/
+function parseProFilteredValue(proFilter, columnProps) {
+	const { filters, onFilter, filteredValue: columnFilteredValue, dataIndex } = columnProps || {};
+	if (columnFilteredValue !== void 0) return columnFilteredValue;
+	if (filters == null) return void 0;
+	if (isLocalFilter(filters, onFilter)) return void 0;
+	const filterKey = parseDataIndex(dataIndex);
+	return filterKey ? proFilter?.[filterKey] : void 0;
+}
+function parseColumnFilterSort(proFilter, proSort, columnProps) {
+	return {
+		filteredValue: parseProFilteredValue(proFilter, columnProps),
+		sortOrder: parseProSortOrder(proSort, columnProps)
+	};
+}
+function resolveOnFilter(columnProps) {
+	const { onFilter, dataIndex } = columnProps;
+	if (onFilter === true) return (value, row) => defaultOnFilter(value, row, dataIndex);
+	return omitBoolean(onFilter);
+}
+function resolveFilters(columnProps) {
+	const { filters = [], valueEnum } = columnProps;
+	if (filters === true) return proFieldParsingValueEnumToArray(runFunction(valueEnum, void 0)).filter((valueItem) => valueItem && valueItem.value !== "all");
+	return filters;
+}
+function getColumnConfig(columnsMap, columnKey, columnProps) {
+	return { fixed: (columnsMap?.[columnKey] || { fixed: columnProps.fixed }).fixed };
+}
+function updateSubNameRecord(rowData, index, keyName, childrenColumnName, subNameRecord) {
+	if (!(Object.prototype.toString.call(rowData) === "[object Object]") || rowData === null || !Reflect.has(rowData, keyName)) return;
+	const record = rowData;
+	const uniqueKey = record?.[keyName];
+	const parentInfo = subNameRecord.get(uniqueKey) || [];
+	(record?.[childrenColumnName])?.forEach((item) => {
+		const itemUniqueKey = item[keyName];
+		if (!subNameRecord.has(itemUniqueKey)) subNameRecord.set(itemUniqueKey, parentInfo.concat([index, childrenColumnName]));
+	});
+	return uniqueKey;
+}
+function createCellRender(columnProps, context, subNameRecord) {
+	let keyName = context.rowKey ?? "id";
+	return (text, rowData, index) => {
+		if (typeof context.rowKey === "function") keyName = context.rowKey(rowData, index);
+		const uniqueKey = updateSubNameRecord(rowData, index, keyName, context.childrenColumnName, subNameRecord);
+		return columnRender({
+			columnProps,
+			text,
+			rowData,
+			index,
+			columnEmptyText: context.columnEmptyText,
+			counter: context.counter,
+			type: context.type,
+			marginSM: context.marginSM,
+			subName: subNameRecord.get(uniqueKey),
+			editableUtils: context.editableUtils
+		});
+	};
+}
+/**
+* 转化 columns 到 pro 的格式 主要是 render 方法的自行实现
+*
+*/
+function genProColumnsToColumns(params, parents) {
+	const { columns, counter, proFilter, proSort, columnEmptyText, marginSM, editableUtils, rowKey = "id", type = "table", childrenColumnName = "children" } = params;
+	const subNameRecord = /* @__PURE__ */ new Map();
+	const columnResizeWidthMap = getColumnResizeWidthMap(columns, params.columnResizeWidthMap);
+	return columns?.map((columnProps, columnsIndex) => {
+		if (columnProps === Table.EXPAND_COLUMN) return columnProps;
+		if (columnProps === Table.SELECTION_COLUMN) return columnProps;
+		const { key, dataIndex, valueEnum, valueType = "text", children } = columnProps;
+		const columnKey = genColumnKey(key || dataIndex?.toString(), [parents?.key, columnsIndex].filter(Boolean).join("-"));
+		if (!valueEnum && !valueType && !children) return {
+			index: columnsIndex,
+			...columnProps
+		};
+		const { filteredValue, sortOrder } = parseColumnFilterSort(proFilter, proSort, columnProps);
+		const { fixed } = getColumnConfig(counter?.columnsMap?.value, columnKey, columnProps);
+		const width = columnResizeWidthMap[columnKey] ?? columnProps.width ?? (columnProps.fixed ? 200 : void 0);
+		const finalColumns = omitUndefinedAndEmptyArr({
+			index: columnsIndex,
+			key: columnKey,
+			...columnProps,
+			title: renderColumnsTitle(columnProps),
+			valueEnum,
+			filters: resolveFilters(columnProps),
+			onFilter: resolveOnFilter(columnProps),
+			filteredValue,
+			sortOrder,
+			fixed,
+			width,
+			children: columnProps.children ? genProColumnsToColumns({
+				...params,
+				columns: columnProps.children || [],
+				columnResizeWidthMap
+			}, {
+				...columnProps,
+				key: columnKey
+			}) : void 0,
+			render: createCellRender(columnProps, {
+				rowKey,
+				type,
+				childrenColumnName,
+				counter,
+				marginSM,
+				columnEmptyText,
+				editableUtils
+			}, subNameRecord)
+		});
+		if (columnProps.resizable) finalColumns.onHeaderCell = (data, cellIndex) => {
+			const headerCellProps = columnProps.onHeaderCell?.(data, cellIndex);
+			return {
+				...headerCellProps,
+				resizable: true,
+				width: finalColumns.width,
+				onResize: (event, { size }) => {
+					columnResizeWidthMap[columnKey] = size.width;
+					finalColumns.width = size.width;
+					headerCellProps?.onResize?.(event, { size });
+				}
+			};
+		};
+		return finalColumns;
+	})?.filter((item) => !item?.hideInTable);
+}
+//#endregion
+export { genColumnKey, genProColumnsToColumns, isLocalFilter, isLocalSorter, parseDataIndex, parseProFilteredValue, parseProSortOrder };

package/dist/utils/index.d.ts

@@ -0,0 +1,122 @@
+import { ActionType, Bordered, BorderedType, FilterValue as FilterValue$1, ProColumns, ProTableInstance, UseFetchDataAction } from "../typing.js";
+import { ComputedRef, ShallowRef, UnwrapRef, VNode } from "vue";
+import * as _$_antdv_vue_pro_form0 from "@antdv-vue/pro-form";
+import { IntlType } from "@antdv-vue/pro-provider";
+import { AddLineOptions, Key, PageInfo, ProFieldValueObjectType, ProFieldValueType, RecordKey, UseEditableUtilType } from "@antdv-vue/pro-utils";
+import { TablePaginationConfig } from "antdv-next";
+import { FilterValue, SortOrder, SorterResult } from "antdv-next/dist/table/index";
+import { GetRowKey } from "@v-c/table";
+
+//#region src/utils/index.d.ts
+/**
+ * 检查值是否存在 为了 避开 0 和 false
+ *
+ * @param value
+ */
+declare function checkUndefinedOrNull(value: any): boolean;
+/**
+ * 合并用户 props 和 预设的 props
+ *
+ * @param pagination
+ * @param pageInfo
+ * @param intl
+ */
+declare function mergePagination<T>(pagination: TablePaginationConfig | boolean | undefined, pageInfo: UnwrapRef<UseFetchDataAction<T>['pageInfo']> & {
+  setPageInfo: any;
+}, intl: IntlType): TablePaginationConfig | false | undefined;
+type PostDataType<T> = (data: T) => T;
+/**
+ * 一个转化的 pipeline 列表
+ *
+ * @param data
+ * @param pipeline
+ */
+declare function postDataPipeline<T>(data: T, pipeline: PostDataType<T>[]): T;
+declare function isBordered(borderType: BorderedType, border?: Bordered): boolean | undefined;
+/**
+ * 获取用户的 action 信息
+ *
+ */
+declare function useActionType<T extends Record<string, any>>(action: UseFetchDataAction<T>, props: {
+  nativeElement: ComputedRef<HTMLDivElement | null | undefined>;
+  focus: () => void;
+  fullScreen: () => Promise<void>;
+  onCleanSelected: () => Promise<void>;
+  resetAll: () => Promise<void>;
+  editableUtils: UseEditableUtilType<T>;
+}): ActionType<any, T>;
+declare function isMergeCell(dom?: VNode<any, any, {
+  colSpan?: string;
+}>): string | false | undefined;
+/**
+ * 根据 key 和 dataIndex 生成唯一 id
+ *
+ * @param key 用户设置的 key
+ * @param index 序列号，理论上唯一
+ */
+declare function genColumnKey(key?: string | number | Key, index?: number | string): string;
+/**
+ * 平铺所有columns, 用于判断是用的是本地筛选/排序
+ * @param columns 列配置
+ */
+declare function flattenColumns<T extends Record<string, any>, ValueType extends (ProFieldValueType | ProFieldValueObjectType)>(columns?: ProColumns<T, ValueType>[]): ProColumns<T, ValueType>[];
+/**
+ * 获取服务端筛选数据
+ * @param filters 筛选数据
+ * @param columns 列配置
+ * @returns 服务端筛选数据
+ */
+declare function getServerFilterResult<T, ValueType>(filters: Record<string, FilterValue | null>, columns: ProColumns<T, ValueType>[]): Record<string, FilterValue$1>;
+/**
+ * 获取服务端排序数据
+ * @param sorterResult 排序数据
+ * @returns 服务端排序数据
+ */
+declare function getServerSorterResult<T extends Record<string, any>>(sorterResult: SorterResult<T> | SorterResult<T>[]): Record<string, SortOrder | undefined>;
+/**
+ * 从 ProColumns 数组中取出默认的排序和筛选数据
+ *
+ * @param columns ProColumns
+ */
+declare function parseServerDefaultColumnConfig<T, ValueType>(columns: ProColumns<T, ValueType>[]): {
+  sort: Record<string, SortOrder>;
+  filter: Record<string, FilterValue$1>;
+};
+declare function useProTableInstanceExpose<T extends Record<string, any>>(tableRef: ShallowRef<ProTableInstance<T> | null>): {
+  readonly nativeElement: HTMLDivElement | null | undefined;
+  readonly pageInfo: PageInfo | undefined;
+  readonly formRef: _$_antdv_vue_pro_form0.ProFormInstance<T> | null;
+  preEditableKeys: ComputedRef<Key[] | undefined>;
+  focus: () => void | undefined;
+  fullScreen: () => Promise<void | undefined>;
+  cleanSelected: () => Promise<void | undefined>;
+  addEditRecord: (row: T, options?: AddLineOptions) => Promise<boolean | undefined>;
+  cancelEditable: (recordKey: RecordKey, needReTry?: boolean) => Promise<boolean | undefined>;
+  getRealIndex: (record: T) => number | undefined;
+  isEditable: (row: T & {
+    index: number;
+  }) => {
+    recordKey: string;
+    isEditable: boolean;
+    preIsEditable: boolean;
+  } | undefined;
+  onValuesChange: (value: T, values: T) => void | undefined;
+  reload: (resetPageIndex?: boolean) => Promise<void | undefined>;
+  reloadAndRest: () => Promise<void | undefined>;
+  reset: () => Promise<void | undefined>;
+  saveEditable: (recordKey: RecordKey, needReTry?: boolean) => Promise<boolean | undefined>;
+  scrollTo: (arg: number | {
+    index?: number | undefined;
+    key?: Key | undefined;
+    top?: number;
+  }) => void | undefined;
+  setPageInfo: (page: Partial<PageInfo>) => Promise<void | undefined>;
+  startEditable: (recordKey: Key, record?: T) => Promise<boolean | undefined>;
+};
+/**
+ * 将 editableKeys 解析为 RowEditableConfig.onChange 的第二参数，
+ * 与 useEditableArray 内 setEditableRowKeys 一致：single 为单条（可为空场景下的 undefined），multiple 为数组。
+ */
+declare function resolveEditingPayloadForRowEditableOnChange<DataType extends Record<string, any>>(keys: Key[], dataSource: readonly DataType[] | undefined, getRowKey: GetRowKey<DataType>, editableType: 'single' | 'multiple' | undefined, childrenColumnName?: string): DataType | DataType[];
+//#endregion
+export { checkUndefinedOrNull, flattenColumns, genColumnKey, getServerFilterResult, getServerSorterResult, isBordered, isMergeCell, mergePagination, parseServerDefaultColumnConfig, postDataPipeline, resolveEditingPayloadForRowEditableOnChange, useActionType, useProTableInstanceExpose };

package/dist/utils/index.js

@@ -0,0 +1,227 @@
+import { isLocalFilter, isLocalSorter } from "./genProColumnsToColumns.js";
+import { computed, isVNode } from "vue";
+//#region src/utils/index.ts
+/**
+* 检查值是否存在 为了 避开 0 和 false
+*
+* @param value
+*/
+function checkUndefinedOrNull(value) {
+	return value !== void 0 && value !== null;
+}
+/**
+* 合并用户 props 和 预设的 props
+*
+* @param pagination
+* @param pageInfo
+* @param intl
+*/
+function mergePagination(pagination, pageInfo, intl) {
+	if (pagination === false) return false;
+	const { total, current, pageSize, setPageInfo } = pageInfo;
+	return {
+		showTotal: (all, range) => `${intl.getMessage({
+			id: "pagination.total.range",
+			defaultMessage: "第"
+		})} ${range[0]}-${range[1]} ${intl.getMessage({
+			id: "pagination.total.total",
+			defaultMessage: "条/总共"
+		})} ${all} ${intl.getMessage({
+			id: "pagination.total.item",
+			defaultMessage: "条"
+		})}`,
+		total,
+		...typeof pagination === "object" ? pagination : {},
+		current: pagination !== true && pagination ? pagination.current ?? current : current,
+		pageSize: pagination !== true && pagination ? pagination.pageSize ?? pageSize : pageSize,
+		onChange: (page, newPageSize) => {
+			const { onChange } = pagination;
+			onChange?.(page, newPageSize || 20);
+			if (newPageSize !== pageSize || current !== page) setPageInfo({
+				pageSize: newPageSize,
+				current: page
+			});
+		}
+	};
+}
+/**
+* 一个转化的 pipeline 列表
+*
+* @param data
+* @param pipeline
+*/
+function postDataPipeline(data, pipeline) {
+	if (pipeline.filter((item) => item).length < 1) return data;
+	return pipeline.reduce((pre, postData) => {
+		return postData(pre);
+	}, data);
+}
+function isBordered(borderType, border) {
+	if (border === void 0) return false;
+	if (typeof border === "boolean") return border;
+	return border[borderType];
+}
+/**
+* 获取用户的 action 信息
+*
+*/
+function useActionType(action, props) {
+	const { messageContextHolder, ...rest } = props.editableUtils;
+	return {
+		...rest,
+		get pageInfo() {
+			return action.pageInfo.value;
+		},
+		get nativeElement() {
+			return props.nativeElement.value;
+		},
+		focus: () => props.focus(),
+		reload: async (resetPageIndex) => {
+			if (resetPageIndex) await action.setPageInfo({ current: 1 });
+			await action?.reload();
+		},
+		reloadAndRest: async () => {
+			await props.onCleanSelected();
+			await action.setPageInfo({ current: 1 });
+			await action?.reload();
+		},
+		reset: async () => {
+			await props.resetAll();
+			await action?.reset?.();
+			await action?.reload();
+		},
+		fullScreen: async () => await props.fullScreen(),
+		clearSelected: async () => await props.onCleanSelected(),
+		setPageInfo: async (rest) => await action.setPageInfo(rest)
+	};
+}
+function isMergeCell(dom) {
+	return dom && isVNode(dom) && dom?.props?.colSpan;
+}
+/**
+* 根据 key 和 dataIndex 生成唯一 id
+*
+* @param key 用户设置的 key
+* @param index 序列号，理论上唯一
+*/
+function genColumnKey(key, index) {
+	if (key) return Array.isArray(key) ? key.join("-") : key.toString();
+	return `${index}`;
+}
+/**
+* 将 ProTable - column - dataIndex 转为字符串形式
+*
+* @param dataIndex Column 中的 dataIndex
+*/
+function parseDataIndex(dataIndex) {
+	if (Array.isArray(dataIndex)) return dataIndex.join(",");
+	return dataIndex?.toString();
+}
+/**
+* 平铺所有columns, 用于判断是用的是本地筛选/排序
+* @param columns 列配置
+*/
+function flattenColumns(columns) {
+	const _columns = [];
+	columns?.forEach((column) => {
+		if (column.children) _columns.push(...flattenColumns(column.children));
+		else _columns.push(column);
+	});
+	return _columns;
+}
+/**
+* 获取服务端筛选数据
+* @param filters 筛选数据
+* @param columns 列配置
+* @returns 服务端筛选数据
+*/
+function getServerFilterResult(filters, columns) {
+	return Object.entries(filters).reduce((acc, [key, value]) => {
+		const column = columns.find((column) => parseDataIndex(column.dataIndex) === key);
+		if (column != null && !isLocalFilter(column.filters, column.onFilter)) acc[key] = value;
+		return acc;
+	}, {});
+}
+/**
+* 获取服务端排序数据
+* @param sorterResult 排序数据
+* @returns 服务端排序数据
+*/
+function getServerSorterResult(sorterResult) {
+	return (Array.isArray(sorterResult) ? sorterResult : [sorterResult]).reduce((acc, item) => {
+		const sorter = item.column?.sorter;
+		if (sorter != null && isLocalSorter(sorter)) return acc;
+		const sortKey = typeof sorter === "string" ? sorter : parseDataIndex(item.column?.dataIndex);
+		if (sortKey != null) acc[sortKey] = item.order;
+		return acc;
+	}, {});
+}
+/**
+* 从 ProColumns 数组中取出默认的排序和筛选数据
+*
+* @param columns ProColumns
+*/
+function parseServerDefaultColumnConfig(columns) {
+	const filter = {};
+	const sort = {};
+	columns.forEach((column) => {
+		const dataIndex = parseDataIndex(column.dataIndex);
+		if (!dataIndex) return;
+		if (column.filters && !isLocalFilter(column.filters, column.onFilter)) filter[dataIndex] = column.defaultFilteredValue ?? null;
+		if (column.sorter && !isLocalSorter(column.sorter)) if (typeof column.sorter === "string") sort[column.sorter] = column.defaultSortOrder ?? null;
+		else sort[dataIndex] = column.defaultSortOrder ?? null;
+	});
+	return {
+		sort,
+		filter
+	};
+}
+function useProTableInstanceExpose(tableRef) {
+	return {
+		get nativeElement() {
+			return tableRef.value?.nativeElement;
+		},
+		get pageInfo() {
+			return tableRef.value?.pageInfo;
+		},
+		get formRef() {
+			return tableRef.value?.formRef?.nativeElement ? tableRef.value?.formRef : null;
+		},
+		preEditableKeys: computed(() => tableRef.value?.preEditableKeys?.value),
+		focus: () => tableRef.value?.focus?.(),
+		fullScreen: async () => await tableRef.value?.fullScreen(),
+		cleanSelected: async () => await tableRef.value?.clearSelected?.(),
+		addEditRecord: async (row, options) => await tableRef.value?.addEditRecord?.(row, options),
+		cancelEditable: async (recordKey, needReTry) => await tableRef.value?.cancelEditable?.(recordKey, needReTry),
+		getRealIndex: (record) => tableRef.value?.getRealIndex?.(record),
+		isEditable: (row) => tableRef.value?.isEditable?.(row),
+		onValuesChange: (value, values) => tableRef.value?.onValuesChange?.(value, values),
+		reload: async (resetPageIndex) => await tableRef.value?.reload?.(resetPageIndex),
+		reloadAndRest: async () => await tableRef.value?.reloadAndRest?.(),
+		reset: async () => await tableRef.value?.reset?.(),
+		saveEditable: async (recordKey, needReTry) => await tableRef.value?.saveEditable?.(recordKey, needReTry),
+		scrollTo: (arg) => tableRef.value?.scrollTo?.(arg),
+		setPageInfo: async (page) => tableRef.value?.setPageInfo(page),
+		startEditable: async (recordKey, record) => await tableRef.value?.startEditable?.(recordKey, record)
+	};
+}
+/**
+* 将 editableKeys 解析为 RowEditableConfig.onChange 的第二参数，
+* 与 useEditableArray 内 setEditableRowKeys 一致：single 为单条（可为空场景下的 undefined），multiple 为数组。
+*/
+function resolveEditingPayloadForRowEditableOnChange(keys, dataSource, getRowKey, editableType, childrenColumnName = "children") {
+	const cleanKeys = keys.filter((key) => key !== void 0);
+	const kvMap = /* @__PURE__ */ new Map();
+	const dig = (records) => {
+		records.forEach((record, index) => {
+			const rowKey = getRowKey(record, index);
+			kvMap.set(rowKey, record);
+			if (record && typeof record === "object" && childrenColumnName in record) dig(record[childrenColumnName] || []);
+		});
+	};
+	dig(dataSource ?? []);
+	const editingRecords = cleanKeys.map((key) => kvMap.get(key)).filter((k) => k !== void 0);
+	return (editableType || "single") === "single" ? editingRecords[0] : editingRecords;
+}
+//#endregion
+export { checkUndefinedOrNull, flattenColumns, genColumnKey, getServerFilterResult, getServerSorterResult, isBordered, isMergeCell, mergePagination, parseServerDefaultColumnConfig, postDataPipeline, resolveEditingPayloadForRowEditableOnChange, useActionType, useProTableInstanceExpose };