niuma-ui 1.3.8 → 2.0.0

package/dist/components/table/src/composables/useRsTableEditLayer.d.ts

@@ -0,0 +1,228 @@
+/**
+ * RsTable 编辑编排层：状态机 + 高亮 + 动作 + Api 编辑切片。
+ *
+ * 分层：
+ * - useRsTableEditLayer：早期挂载（须在 Shell 之前，供 isEditingAny）
+ * - bindActions：Shell 交互就绪后绑定提交/键盘/粘贴
+ * - toApiEditSlice：供 createRsTableApi 拼装，避免 expose 与内部漂移
+ *
+ * 性能：草稿/undo 仍用 shallow Map；不在此对 data 做 deep watch。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import type { RsTableColumn, RsTableRowData, RsTableRowEntry } from '../utils/table-utils';
+import type { RsTableApi } from '../rs-table-api';
+import { type UseRsTableEditActionsOptions } from './useRsTableEditActions';
+export interface UseRsTableEditLayerOptions {
+    editable: () => boolean;
+    editGutter: () => boolean;
+    editGutterWidth: () => number | undefined;
+    showIndex: () => boolean;
+    indexWidth: () => number | undefined;
+    rowCommit: () => boolean;
+    showRowStatus: () => boolean;
+    editUndoLimit: () => number | undefined;
+    highlightRow: () => boolean;
+    highlightRowOnClick: () => boolean;
+    highlightedRowKey: () => string | undefined;
+    defaultHighlightedRowKey: () => string | undefined;
+    onHighlightUpdate: (value: string | undefined) => void;
+    /** 共享 tooltip / 插槽探测 */
+    cellTooltip: () => boolean;
+    hasColumnSlot: (key: string) => boolean;
+}
+/**
+ * Api 中与编辑/高亮相关的方法切片（不含行查询与 analytics）。
+ */
+export type RsTableApiEditSlice<T extends RsTableRowData> = Pick<RsTableApi<T>, 'getHighlightedRowKey' | 'setHighlightedRowKey' | 'cancelCellEdit' | 'cancelAllEdits' | 'getDirtyCellKeys' | 'getCellError' | 'setCellError' | 'stageCell' | 'rejectRowEdit' | 'undoEdit' | 'redoEdit' | 'commitRowEdits' | 'rollbackRowEdits'>;
+/**
+ * 编辑层：早期状态 + 延迟 bindActions。
+ */
+export declare function useRsTableEditLayer<T extends RsTableRowData>(options: UseRsTableEditLayerOptions): {
+    tableEdit: {
+        editingCell: Ref<import("./useTableEdit").RsTableEditingCell | null>;
+        editingDraft: Ref<string>;
+        focusCell: Ref<import("./useTableEdit").RsTableFocusCell | null>;
+        stagedMap: Ref<Map<string, import("./useTableEdit").RsTableStagedCell>>;
+        errorMap: Ref<Map<string, string>>;
+        validatingMap: Ref<Map<string, boolean>>;
+        undoStack: Ref<import("./useTableEdit").RsTableUndoEntry[]>;
+        redoStack: Ref<import("./useTableEdit").RsTableUndoEntry[]>;
+        isEditing: (rowKey: string, colKey: string) => boolean;
+        isFocused: (rowKey: string, colKey: string) => boolean;
+        getDraft: (rowKey: string, colKey: string) => string | undefined;
+        isDirty: (rowKey: string, colKey: string) => boolean;
+        isRowDirty: (rowKey: string) => boolean;
+        getCellError: (rowKey: string, colKey: string) => string | undefined;
+        setCellError: (rowKey: string, colKey: string, message: string | null) => void;
+        clearCellError: (rowKey: string, colKey: string) => void;
+        isValidating: (rowKey: string, colKey: string) => boolean;
+        setValidating: (rowKey: string, colKey: string, value: boolean) => void;
+        getRowStagedCells: (rowKey: string) => import("./useTableEdit").RsTableStagedCell[];
+        startEdit: (cell: import("./useTableEdit").RsTableEditingCell, initialText: string) => void;
+        updateDraft: (text: string) => void;
+        cancelEdit: () => void;
+        cancelAll: () => void;
+        setFocusCell: (cell: import("./useTableEdit").RsTableFocusCell | null) => void;
+        stageCell: (cell: import("./useTableEdit").RsTableStagedCell) => void;
+        unstageCell: (rowKey: string, colKey: string) => void;
+        rollbackRow: (rowKey: string) => void;
+        commitRow: (rowKey: string) => import("./useTableEdit").RsTableStagedCell[];
+        pushUndo: (entry: import("./useTableEdit").RsTableUndoEntry | import("./useTableEdit").RsTableUndoEntry["items"][number]) => void;
+        undo: () => import("./useTableEdit").RsTableUndoEntry | null;
+        redo: () => import("./useTableEdit").RsTableUndoEntry | null;
+    };
+    rowHighlight: {
+        highlightedKey: ComputedRef<string | undefined>;
+        setHighlightedKey: (value: string | undefined) => void;
+        isHighlighted: (rowKey: string) => boolean;
+        applyRowClickHighlight: (rowKey: string) => void;
+    };
+    showEditGutterColumn: ComputedRef<boolean>;
+    showIndexColumn: ComputedRef<boolean>;
+    showRowStatusColumn: ComputedRef<boolean>;
+    resolvedGutterWidth: ComputedRef<number>;
+    resolvedIndexWidth: ComputedRef<number>;
+    activeEditCellKey: ComputedRef<string>;
+    activeFocusCellKey: ComputedRef<string>;
+    activeErrorMapSize: ComputedRef<number>;
+    activeValidatingMapSize: ComputedRef<number>;
+    isEditingAny: () => boolean;
+    cellTooltipEnabled: (column: RsTableColumn<T>, _rowIndex: number) => boolean;
+    cellTooltipMode: (column: RsTableColumn<T>, rowIndex: number) => string | undefined;
+    cellTooltipText: (column: RsTableColumn<T>, row: T, rowIndex: number) => string | undefined;
+    cellTooltipFallbackTitle: (column: RsTableColumn<T>, row: T, rowIndex: number) => string | undefined;
+    bindActions: (actionOptions: Omit<UseRsTableEditActionsOptions<T>, "tableEdit" | "applyRowClickHighlight">) => {
+        getRowByKey: (rowKey: string, dataRows: Array<Extract<RsTableRowEntry<T>, {
+            type: "row";
+        }>>, rowKeyByIndex: Map<number, string>) => T | undefined;
+        getRowByIndex: (index: number, dataRows: Array<Extract<RsTableRowEntry<T>, {
+            type: "row";
+        }>>) => T | undefined;
+        getColumnValues: (colKey: string, dataRows: Array<Extract<RsTableRowEntry<T>, {
+            type: "row";
+        }>>) => unknown[];
+        getCellValue: (rowKey: string, colKey: string, dataRows: Array<Extract<RsTableRowEntry<T>, {
+            type: "row";
+        }>>, rowKeyByIndex: Map<number, string>) => unknown;
+        toApiEditSlice: (ctx: {
+            dataRows: Ref<Array<Extract<RsTableRowEntry<T>, {
+                type: "row";
+            }>>> | ComputedRef<Array<Extract<RsTableRowEntry<T>, {
+                type: "row";
+            }>>>;
+            rowKeyByIndex: Ref<Map<number, string>> | ComputedRef<Map<number, string>>;
+        }) => RsTableApiEditSlice<T>;
+        resolveColumnByKey: (colKey: string) => RsTableColumn<T> | undefined;
+        findRowEntryByKey: (rowKey: string) => {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        } | undefined;
+        onCellStartEdit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }, colKey: string) => void;
+        onCellUpdateDraft: (_entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }, _colKey: string, value: string) => void;
+        onCellCancelEdit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }, colKey: string) => void;
+        onCellCommitEdit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }, colKey: string, rawText: string, commitOptions?: {
+            navigate?: import("../..").RsTableCellNavigateDirection;
+            skipUndo?: boolean;
+            skipBatch?: boolean;
+        } | undefined) => Promise<boolean>;
+        onCellNavigate: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }, colKey: string, direction: import("../..").RsTableCellNavigateDirection) => Promise<void>;
+        onCellClick: (entry: RsTableRowEntry<T>, colKey: string, event?: MouseEvent) => void;
+        onCellDblclick: (entry: RsTableRowEntry<T>, colKey: string, event?: MouseEvent) => void;
+        onEditUndo: () => void;
+        onEditRedo: () => void;
+        onTableKeydown: (event: KeyboardEvent) => void;
+        onTablePaste: (event: ClipboardEvent) => void;
+        rejectRowEdit: (rowKey: string, reason?: string) => void;
+        onRowCommitEdit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }) => Promise<void>;
+        onRowRollbackEdit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }) => void;
+        isExternalRowPending: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }) => boolean;
+        rowEditPending: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }) => boolean;
+        onGutterCommit: (entry: {
+            type: "row";
+            row: T;
+            rowIndex: number;
+            depth?: number;
+            hasChildren?: boolean;
+            parentKey?: string | null;
+            treeKey?: string;
+        }) => void;
+    };
+};
+export type RsTableEditLayerApi<T extends RsTableRowData> = ReturnType<typeof useRsTableEditLayer<T>>;

package/dist/components/table/src/composables/useRsTableEditLayer.js

@@ -0,0 +1,146 @@
+import { columnUsesSharedTooltip, resolveCellTooltipMode, resolveCellTooltipText } from "../utils/table-utils.js";
+import { resolveColumnRawValue } from "../utils/table-edit-utils.js";
+import { useTableEdit } from "./useTableEdit.js";
+import { useTableRowHighlight } from "./useTableRowHighlight.js";
+import { useRsTableEditActions } from "./useRsTableEditActions.js";
+import { computed } from "vue";
+//#region src/components/table/src/composables/useRsTableEditLayer.ts
+/**
+* RsTable 编辑编排层：状态机 + 高亮 + 动作 + Api 编辑切片。
+*
+* 分层：
+* - useRsTableEditLayer：早期挂载（须在 Shell 之前，供 isEditingAny）
+* - bindActions：Shell 交互就绪后绑定提交/键盘/粘贴
+* - toApiEditSlice：供 createRsTableApi 拼装，避免 expose 与内部漂移
+*
+* 性能：草稿/undo 仍用 shallow Map；不在此对 data 做 deep watch。
+*/
+/**
+* 编辑层：早期状态 + 延迟 bindActions。
+*/
+function useRsTableEditLayer(options) {
+	const showEditGutterColumn = computed(() => options.editable() && options.editGutter());
+	const showIndexColumn = computed(() => options.showIndex() && !showEditGutterColumn.value);
+	const showRowStatusColumn = computed(() => options.rowCommit() && options.showRowStatus() && !showEditGutterColumn.value);
+	const resolvedGutterWidth = computed(() => Math.max(24, options.editGutterWidth() || 32));
+	const resolvedIndexWidth = computed(() => Math.max(24, options.indexWidth() || 48));
+	const tableEdit = useTableEdit({
+		enabled: () => options.editable(),
+		undoLimit: () => options.editUndoLimit()
+	});
+	const activeEditCellKey = computed(() => {
+		const cell = tableEdit.editingCell.value;
+		return cell ? `${cell.rowKey}:${cell.colKey}` : "";
+	});
+	const activeFocusCellKey = computed(() => {
+		const cell = tableEdit.focusCell.value;
+		return cell ? `${cell.rowKey}:${cell.colKey}` : "";
+	});
+	const activeErrorMapSize = computed(() => tableEdit.errorMap.value.size);
+	const activeValidatingMapSize = computed(() => tableEdit.validatingMap.value.size);
+	const isHighlightControlled = computed(() => options.highlightedRowKey() !== void 0);
+	const rowHighlight = useTableRowHighlight({
+		enabled: () => options.highlightRow(),
+		highlightRowOnClick: () => options.highlightRowOnClick(),
+		isControlled: () => isHighlightControlled.value,
+		highlightedRowKey: () => options.highlightedRowKey(),
+		defaultHighlightedRowKey: () => options.defaultHighlightedRowKey(),
+		onUpdate: options.onHighlightUpdate
+	});
+	function cellTooltipEnabled(column, _rowIndex) {
+		return options.cellTooltip() && columnUsesSharedTooltip(column);
+	}
+	function cellTooltipMode(column, rowIndex) {
+		if (!cellTooltipEnabled(column, rowIndex)) return void 0;
+		return resolveCellTooltipMode(column) ?? void 0;
+	}
+	function cellTooltipText(column, row, rowIndex) {
+		if (!cellTooltipEnabled(column, rowIndex)) return void 0;
+		return resolveCellTooltipText(column, row, rowIndex) || void 0;
+	}
+	function cellTooltipFallbackTitle(column, row, rowIndex) {
+		if (options.cellTooltip() || !column.ellipsis || options.hasColumnSlot(column.key)) return;
+		return resolveCellTooltipText(column, row, rowIndex) || void 0;
+	}
+	/**
+	* Shell 就绪后绑定编辑动作（依赖 rowKeyFor / onRowClick）。
+	*/
+	function bindActions(actionOptions) {
+		const actions = useRsTableEditActions({
+			...actionOptions,
+			tableEdit,
+			applyRowClickHighlight: (key) => rowHighlight.applyRowClickHighlight(key)
+		});
+		function getRowByKey(rowKey, dataRows, rowKeyByIndex) {
+			return dataRows.find((item) => rowKeyByIndex.get(item.rowIndex) === rowKey)?.row;
+		}
+		function getRowByIndex(index, dataRows) {
+			return dataRows.find((item) => item.rowIndex === index)?.row;
+		}
+		function getColumnValues(colKey, dataRows) {
+			const column = actions.resolveColumnByKey(colKey);
+			if (!column) return [];
+			return dataRows.map((entry) => resolveColumnRawValue(entry.row, column, entry.rowIndex));
+		}
+		function getCellValue(rowKey, colKey, dataRows, rowKeyByIndex) {
+			const row = getRowByKey(rowKey, dataRows, rowKeyByIndex);
+			const column = actions.resolveColumnByKey(colKey);
+			if (!row || !column) return void 0;
+			const entry = dataRows.find((item) => rowKeyByIndex.get(item.rowIndex) === rowKey);
+			if (!entry) return void 0;
+			return resolveColumnRawValue(entry.row, column, entry.rowIndex);
+		}
+		function toApiEditSlice(ctx) {
+			return {
+				getHighlightedRowKey: () => rowHighlight.highlightedKey.value,
+				setHighlightedRowKey: rowHighlight.setHighlightedKey,
+				cancelCellEdit: () => tableEdit.cancelEdit(),
+				cancelAllEdits: () => tableEdit.cancelAll(),
+				getDirtyCellKeys: () => [...tableEdit.stagedMap.value.keys()],
+				getCellError: tableEdit.getCellError,
+				setCellError: tableEdit.setCellError,
+				stageCell: tableEdit.stageCell,
+				rejectRowEdit: actions.rejectRowEdit,
+				undoEdit: actions.onEditUndo,
+				redoEdit: actions.onEditRedo,
+				commitRowEdits: (rowKey) => {
+					const entry = ctx.dataRows.value.find((item) => ctx.rowKeyByIndex.value.get(item.rowIndex) === rowKey);
+					if (entry) actions.onRowCommitEdit(entry);
+				},
+				rollbackRowEdits: (rowKey) => {
+					const entry = ctx.dataRows.value.find((item) => ctx.rowKeyByIndex.value.get(item.rowIndex) === rowKey);
+					if (entry) actions.onRowRollbackEdit(entry);
+				}
+			};
+		}
+		return {
+			...actions,
+			getRowByKey,
+			getRowByIndex,
+			getColumnValues,
+			getCellValue,
+			toApiEditSlice
+		};
+	}
+	return {
+		tableEdit,
+		rowHighlight,
+		showEditGutterColumn,
+		showIndexColumn,
+		showRowStatusColumn,
+		resolvedGutterWidth,
+		resolvedIndexWidth,
+		activeEditCellKey,
+		activeFocusCellKey,
+		activeErrorMapSize,
+		activeValidatingMapSize,
+		isEditingAny: () => Boolean(tableEdit.editingCell.value),
+		cellTooltipEnabled,
+		cellTooltipMode,
+		cellTooltipText,
+		cellTooltipFallbackTitle,
+		bindActions
+	};
+}
+//#endregion
+export { useRsTableEditLayer };

package/dist/components/table/src/composables/useRsTableEngine.d.ts

@@ -0,0 +1,115 @@
+/**
+ * RsTable 数据内核：排序 / 筛选 / 分组后的 entries，以及选择、展开、树索引。
+ *
+ * 职责边界：
+ * - 做：受控/非受控 sort、selection、expand；构建 tableEntries / viewRows
+ * - 不做：虚拟滚动、列宽、右键菜单 DOM、行内编辑提交（由 RsTable + 其它 composable 负责）
+ *
+ * `viewRows` 供 summary / 表外 analytics 使用（仅业务行，不含 group/expand 伪行）。
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import { type RsTableColumn, type RsTableGroupBy, type RsTableRowData, type RsTableRowEntry, type RsTableRowKey, type RsTableSize, type RsTableSortState, type RsTableTreeConfig } from '../utils/table-utils';
+/** Engine 向外发出的状态同步事件（与 RsTable emit 子集对齐） */
+export interface UseRsTableEngineEmit {
+    (e: 'update:selectedRowKeys', value: string[]): void;
+    (e: 'selectionChange', value: string[]): void;
+    (e: 'update:expandedRowKeys', value: string[]): void;
+    (e: 'expandChange', value: string[]): void;
+    (e: 'update:sort', value: RsTableSortState | null): void;
+    (e: 'update:sorts', value: RsTableSortState[]): void;
+    (e: 'sortsChange', value: RsTableSortState[]): void;
+}
+/**
+ * useRsTableEngine 入参。
+ * 数据源与列定义通过 getter/ComputedRef 注入，避免在 Engine 内直接依赖整个 props 对象。
+ */
+export interface UseRsTableEngineOptions<T extends RsTableRowData> {
+    data: ComputedRef<T[]> | (() => T[]);
+    /** 已排序/钉住展开列后的展示列（通常来自 useRsTableColumns.displayColumns） */
+    displayColumns: ComputedRef<RsTableColumn<T>[]> | (() => RsTableColumn<T>[]);
+    rowKey: ComputedRef<RsTableRowKey<T> | undefined> | (() => RsTableRowKey<T> | undefined);
+    sort: ComputedRef<RsTableSortState | null | undefined> | (() => RsTableSortState | null | undefined);
+    defaultSort: RsTableSortState | null;
+    sorts: ComputedRef<RsTableSortState[] | undefined> | (() => RsTableSortState[] | undefined);
+    defaultSorts: RsTableSortState[];
+    multiSort: ComputedRef<boolean> | (() => boolean);
+    remoteSort: ComputedRef<boolean> | (() => boolean);
+    filterText: ComputedRef<string | undefined> | (() => string | undefined);
+    filterKeys: ComputedRef<string[] | undefined> | (() => string[] | undefined);
+    columnFilters: ComputedRef<Record<string, string>> | (() => Record<string, string>);
+    groupBy: ComputedRef<RsTableGroupBy<T> | undefined> | (() => RsTableGroupBy<T> | undefined);
+    groupLabel: ComputedRef<((key: string) => string) | undefined> | (() => ((key: string) => string) | undefined);
+    treeConfig: ComputedRef<RsTableTreeConfig<T> | undefined> | (() => RsTableTreeConfig<T> | undefined);
+    expandable: ComputedRef<boolean> | (() => boolean);
+    rowExpandable: ComputedRef<((row: T, index: number) => boolean) | undefined> | (() => ((row: T, index: number) => boolean) | undefined);
+    selectedRowKeys: ComputedRef<string[] | undefined> | (() => string[] | undefined);
+    defaultSelectedRowKeys: string[];
+    expandedRowKeys: ComputedRef<string[] | undefined> | (() => string[] | undefined);
+    defaultExpandedRowKeys: string[];
+    rowSelectable: ComputedRef<((row: T, index: number) => boolean) | undefined> | (() => ((row: T, index: number) => boolean) | undefined);
+    size: ComputedRef<RsTableSize> | (() => RsTableSize);
+    emit: UseRsTableEngineEmit;
+}
+/**
+ * 表格数据内核。
+ *
+ * @returns 排序状态、选择/展开、树字段、tableEntries、dataRows、viewRows 等；
+ *          行勾选/展开的「交互处理函数」仍留在 RsTable（依赖 DOM 与其它 UI 状态）。
+ */
+export declare function useRsTableEngine<T extends RsTableRowData>(options: UseRsTableEngineOptions<T>): {
+    internalSort: Ref<{
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    } | null, RsTableSortState | {
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    } | null>;
+    internalSorts: Ref<{
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    }[], RsTableSortState[] | {
+        key: string;
+        order: Exclude<import("../..").RsTableSortOrder, null>;
+    }[]>;
+    internalSelectedRowKeys: Ref<string[], string[]>;
+    internalExpandedRowKeys: Ref<string[], string[]>;
+    treeLoadingKeys: Ref<string[], string[]>;
+    isSortControlled: ComputedRef<boolean>;
+    sortState: import("vue").WritableComputedRef<RsTableSortState | null, RsTableSortState | null>;
+    isSortsControlled: ComputedRef<boolean>;
+    sortsState: import("vue").WritableComputedRef<RsTableSortState[], RsTableSortState[]>;
+    isSelectionControlled: ComputedRef<boolean>;
+    selectedRowKeys: import("vue").WritableComputedRef<string[], string[]>;
+    selectedKeySet: ComputedRef<Set<string>>;
+    isExpandedControlled: ComputedRef<boolean>;
+    expandedRowKeys: import("vue").WritableComputedRef<string[], string[]>;
+    expandedKeySet: ComputedRef<Set<string>>;
+    treeMode: ComputedRef<boolean>;
+    detailExpandable: ComputedRef<boolean>;
+    treeChildrenField: ComputedRef<string>;
+    treeIsLeafField: ComputedRef<string>;
+    treeLazy: ComputedRef<boolean>;
+    treeCheckStrictly: ComputedRef<boolean>;
+    treeIndentPx: ComputedRef<number>;
+    treeExpandColumnKey: ComputedRef<string | null>;
+    treeFixExpandColumn: ComputedRef<boolean>;
+    treeLoadingKeySet: ComputedRef<Set<string>>;
+    tableTreeNodeIndex: ComputedRef<Map<string, import("../..").RsTableTreeNodeIndex> | null>;
+    tableEntries: ComputedRef<RsTableRowEntry<T>[]>;
+    dataRows: ComputedRef<{
+        type: "row";
+        row: T;
+        rowIndex: number;
+        depth?: number;
+        hasChildren?: boolean;
+        parentKey?: string | null;
+        treeKey?: string;
+    }[]>;
+    selectableRowKeys: ComputedRef<string[]>;
+    rowKeyByIndex: ComputedRef<Map<number, string>>;
+    selectedRows: ComputedRef<T[]>;
+    selectAllState: ComputedRef<import("../..").RsTableSelectAllState>;
+    viewRows: ComputedRef<T[]>;
+};
+/** useRsTableEngine 返回值类型 */
+export type RsTableEngineApi<T extends RsTableRowData> = ReturnType<typeof useRsTableEngine<T>>;