niuma-ui 1.1.12 → 1.2.0

package/src/composables/useRsTableEditLayer.ts

@@ -1,251 +0,0 @@
-/**
- * RsTable 编辑编排层：状态机 + 高亮 + 动作 + Api 编辑切片。
- *
- * 分层：
- * - useRsTableEditLayer：早期挂载（须在 Shell 之前，供 isEditingAny）
- * - bindActions：Shell 交互就绪后绑定提交/键盘/粘贴
- * - toApiEditSlice：供 createRsTableApi 拼装，避免 expose 与内部漂移
- *
- * 性能：草稿/undo 仍用 shallow Map；不在此对 data 做 deep watch。
- */
-
-import { computed, type ComputedRef, type Ref } from 'vue'
-import type { RsTableColumn, RsTableRowData, RsTableRowEntry } from '../components/table-utils'
-import {
-  columnUsesSharedTooltip,
-  resolveCellTooltipMode,
-  resolveCellTooltipText,
-} from '../components/table-utils'
-import { resolveColumnRawValue } from '../components/table/table-edit-utils'
-import type { RsTableApi } from '../components/table/rs-table-api'
-import { useTableEdit } from './useTableEdit'
-import { useTableRowHighlight } from './useTableRowHighlight'
-import {
-  useRsTableEditActions,
-  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 function useRsTableEditLayer<T extends RsTableRowData>(
-  options: UseRsTableEditLayerOptions,
-) {
-  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() !== undefined)
-  const rowHighlight = useTableRowHighlight({
-    enabled: () => options.highlightRow(),
-    highlightRowOnClick: () => options.highlightRowOnClick(),
-    isControlled: () => isHighlightControlled.value,
-    highlightedRowKey: () => options.highlightedRowKey(),
-    defaultHighlightedRowKey: () => options.defaultHighlightedRowKey(),
-    onUpdate: options.onHighlightUpdate,
-  })
-
-  function cellTooltipEnabled(column: RsTableColumn<T>, _rowIndex: number): boolean {
-    return options.cellTooltip() && columnUsesSharedTooltip(column)
-  }
-
-  function cellTooltipMode(column: RsTableColumn<T>, rowIndex: number): string | undefined {
-    if (!cellTooltipEnabled(column, rowIndex)) return undefined
-    return resolveCellTooltipMode(column) ?? undefined
-  }
-
-  function cellTooltipText(column: RsTableColumn<T>, row: T, rowIndex: number): string | undefined {
-    if (!cellTooltipEnabled(column, rowIndex)) return undefined
-    const text = resolveCellTooltipText(column, row, rowIndex)
-    return text || undefined
-  }
-
-  function cellTooltipFallbackTitle(
-    column: RsTableColumn<T>,
-    row: T,
-    rowIndex: number,
-  ): string | undefined {
-    if (options.cellTooltip() || !column.ellipsis || options.hasColumnSlot(column.key)) {
-      return undefined
-    }
-    const text = resolveCellTooltipText(column, row, rowIndex)
-    return text || undefined
-  }
-
-  /**
-   * Shell 就绪后绑定编辑动作（依赖 rowKeyFor / onRowClick）。
-   */
-  function bindActions(
-    actionOptions: Omit<UseRsTableEditActionsOptions<T>, 'tableEdit' | 'applyRowClickHighlight'>,
-  ) {
-    const actions = useRsTableEditActions<T>({
-      ...actionOptions,
-      tableEdit,
-      applyRowClickHighlight: (key) => rowHighlight.applyRowClickHighlight(key),
-    })
-
-    function getRowByKey(
-      rowKey: string,
-      dataRows: Array<Extract<RsTableRowEntry<T>, { type: 'row' }>>,
-      rowKeyByIndex: Map<number, string>,
-    ): T | undefined {
-      const entry = dataRows.find((item) => rowKeyByIndex.get(item.rowIndex) === rowKey)
-      return entry?.row
-    }
-
-    function getRowByIndex(
-      index: number,
-      dataRows: Array<Extract<RsTableRowEntry<T>, { type: 'row' }>>,
-    ): T | undefined {
-      return dataRows.find((item) => item.rowIndex === index)?.row
-    }
-
-    function getColumnValues(
-      colKey: string,
-      dataRows: Array<Extract<RsTableRowEntry<T>, { type: 'row' }>>,
-    ): unknown[] {
-      const column = actions.resolveColumnByKey(colKey)
-      if (!column) return []
-      return dataRows.map((entry) => resolveColumnRawValue(entry.row, column, entry.rowIndex))
-    }
-
-    function getCellValue(
-      rowKey: string,
-      colKey: string,
-      dataRows: Array<Extract<RsTableRowEntry<T>, { type: 'row' }>>,
-      rowKeyByIndex: Map<number, string>,
-    ): unknown {
-      const row = getRowByKey(rowKey, dataRows, rowKeyByIndex)
-      const column = actions.resolveColumnByKey(colKey)
-      if (!row || !column) return undefined
-      const entry = dataRows.find((item) => rowKeyByIndex.get(item.rowIndex) === rowKey)
-      if (!entry) return undefined
-      return resolveColumnRawValue(entry.row, column, entry.rowIndex)
-    }
-
-    function 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> {
-      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: string) => {
-          const entry = ctx.dataRows.value.find(
-            (item) => ctx.rowKeyByIndex.value.get(item.rowIndex) === rowKey,
-          )
-          if (entry) void actions.onRowCommitEdit(entry)
-        },
-        rollbackRowEdits: (rowKey: string) => {
-          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,
-  }
-}
-
-export type RsTableEditLayerApi<T extends RsTableRowData> = ReturnType<
-  typeof useRsTableEditLayer<T>
->

package/src/composables/useRsTableEngine.ts

@@ -1,357 +0,0 @@
-/**
- * RsTable 数据内核：排序 / 筛选 / 分组后的 entries，以及选择、展开、树索引。
- *
- * 职责边界：
- * - 做：受控/非受控 sort、selection、expand；构建 tableEntries / viewRows
- * - 不做：虚拟滚动、列宽、右键菜单 DOM、行内编辑提交（由 RsTable + 其它 composable 负责）
- *
- * `viewRows` 供 summary / 表外 analytics 使用（仅业务行，不含 group/expand 伪行）。
- */
-
-import { computed, ref, watch, type ComputedRef, type Ref } from 'vue'
-import {
-  buildTableEntries,
-  buildTableTreeEntries,
-  buildTableTreeNodeIndex,
-  collectTableTreeExpandableKeys,
-  hasStableTableTreeRowKey,
-  injectExpandRows,
-  isTableRowDisabled,
-  resolveRowKey,
-  resolveSelectAllState,
-  resolveTableTreeIndent,
-  type RsTableColumn,
-  type RsTableGroupBy,
-  type RsTableRowData,
-  type RsTableRowEntry,
-  type RsTableRowKey,
-  type RsTableSize,
-  type RsTableSortState,
-  type RsTableTreeConfig,
-} from '../components/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
-}
-
-/** 统一读取 ComputedRef / Ref / getter */
-function read<T>(source: ComputedRef<T> | (() => T) | Ref<T>): T {
-  if (typeof source === 'function') return (source as () => T)()
-  return (source as Ref<T> | ComputedRef<T>).value
-}
-
-/**
- * 表格数据内核。
- *
- * @returns 排序状态、选择/展开、树字段、tableEntries、dataRows、viewRows 等；
- *          行勾选/展开的「交互处理函数」仍留在 RsTable（依赖 DOM 与其它 UI 状态）。
- */
-export function useRsTableEngine<T extends RsTableRowData>(options: UseRsTableEngineOptions<T>) {
-  const internalSort = ref<RsTableSortState | null>(options.defaultSort ?? null)
-  const internalSorts = ref<RsTableSortState[]>([...options.defaultSorts])
-  const internalSelectedRowKeys = ref<string[]>([...options.defaultSelectedRowKeys])
-  const internalExpandedRowKeys = ref<string[]>([...options.defaultExpandedRowKeys])
-  /** 树懒加载中的行 key（UI loading 用） */
-  const treeLoadingKeys = ref<string[]>([])
-
-  const isSortControlled = computed(() => read(options.sort) !== undefined)
-
-  /** 单列排序状态（受控或内部） */
-  const sortState = computed({
-    get: () => (isSortControlled.value ? read(options.sort) ?? null : internalSort.value),
-    set: (value: RsTableSortState | null) => {
-      if (isSortControlled.value) options.emit('update:sort', value)
-      else internalSort.value = value
-    },
-  })
-
-  const isSortsControlled = computed(() => read(options.sorts) !== undefined)
-
-  /** 多列排序状态 */
-  const sortsState = computed({
-    get: () => (isSortsControlled.value ? read(options.sorts) ?? [] : internalSorts.value),
-    set: (value: RsTableSortState[]) => {
-      if (isSortsControlled.value) options.emit('update:sorts', value)
-      else internalSorts.value = value
-      options.emit('sortsChange', value)
-    },
-  })
-
-  const isSelectionControlled = computed(() => read(options.selectedRowKeys) !== undefined)
-
-  /** 已选行 key 列表；写入时同步 selectionChange */
-  const selectedRowKeys = computed({
-    get: () =>
-      isSelectionControlled.value ? read(options.selectedRowKeys) ?? [] : internalSelectedRowKeys.value,
-    set: (value: string[]) => {
-      if (isSelectionControlled.value) options.emit('update:selectedRowKeys', value)
-      else internalSelectedRowKeys.value = value
-      options.emit('selectionChange', value)
-    },
-  })
-  const selectedKeySet = computed(() => new Set(selectedRowKeys.value))
-
-  const isExpandedControlled = computed(() => read(options.expandedRowKeys) !== undefined)
-
-  /** 展开行 key（明细展开或树展开共用） */
-  const expandedRowKeys = computed({
-    get: () =>
-      isExpandedControlled.value ? read(options.expandedRowKeys) ?? [] : internalExpandedRowKeys.value,
-    set: (value: string[]) => {
-      if (isExpandedControlled.value) options.emit('update:expandedRowKeys', value)
-      else internalExpandedRowKeys.value = value
-      options.emit('expandChange', value)
-    },
-  })
-  const expandedKeySet = computed(() => new Set(expandedRowKeys.value))
-
-  const treeMode = computed(() => Boolean(read(options.treeConfig)))
-  /** 明细行展开：与 tree 互斥，树表下强制关闭 */
-  const detailExpandable = computed(() => read(options.expandable) && !treeMode.value)
-  const treeChildrenField = computed(() => read(options.treeConfig)?.childrenField ?? 'children')
-  const treeIsLeafField = computed(() => read(options.treeConfig)?.isLeafField ?? 'isLeaf')
-  const treeLazy = computed(() => Boolean(read(options.treeConfig)?.lazy))
-  /** 默认严格勾选（父子不联动）；checkStrictly === false 时启用级联 */
-  const treeCheckStrictly = computed(() => read(options.treeConfig)?.checkStrictly !== false)
-  const treeIndentPx = computed(() =>
-    resolveTableTreeIndent(read(options.size), read(options.treeConfig)?.indent),
-  )
-  const treeExpandColumnKey = computed(() => {
-    const tree = read(options.treeConfig)
-    if (!tree) return null
-    return tree.expandColumnKey ?? read(options.displayColumns)[0]?.key ?? null
-  })
-  const treeFixExpandColumn = computed(() => read(options.treeConfig)?.fixExpandColumn !== false)
-  const treeLoadingKeySet = computed(() => new Set(treeLoadingKeys.value))
-
-  /** 全树索引：仅非严格勾选时构建，供级联半选等使用 */
-  const tableTreeNodeIndex = computed(() => {
-    const tree = read(options.treeConfig)
-    if (!tree || treeCheckStrictly.value) return null
-    return buildTableTreeNodeIndex(read(options.data), {
-      childrenField: treeChildrenField.value,
-      isLeafField: treeIsLeafField.value,
-      lazy: treeLazy.value,
-      rowKey: read(options.rowKey),
-    })
-  })
-
-  if (import.meta.env.DEV) {
-    watch(
-      () => [read(options.treeConfig), read(options.expandable), read(options.groupBy)] as const,
-      ([tree, expandable, groupBy]) => {
-        if (!tree) return
-        if (expandable) {
-          console.warn('[RsTable] treeConfig 与 expandable（明细展开）互斥，已优先使用 treeConfig')
-        }
-        if (groupBy) {
-          console.warn('[RsTable] treeConfig 与 groupBy 互斥，已忽略 groupBy')
-        }
-      },
-      { immediate: true },
-    )
-    watch(
-      () => [read(options.treeConfig), read(options.rowKey)] as const,
-      ([tree, rowKey]) => {
-        if (!tree) return
-        if (!hasStableTableTreeRowKey(rowKey)) {
-          console.warn(
-            '[RsTable] 树表必须提供稳定的 rowKey（字段名或函数），否则跨分支节点可能 key 碰撞；当前将回退为路径 key。',
-          )
-        }
-      },
-      { immediate: true },
-    )
-  }
-
-  /** defaultExpandAll 是否已种过种子（避免空数据把 seeded 提前锁死） */
-  const treeExpandAllSeeded = ref(false)
-  watch(
-    () => read(options.data),
-    (data) => {
-      const tree = read(options.treeConfig)
-      if (!tree?.defaultExpandAll) return
-      if (isExpandedControlled.value) return
-      if (treeExpandAllSeeded.value) return
-      if (options.defaultExpandedRowKeys.length > 0) {
-        treeExpandAllSeeded.value = true
-        return
-      }
-      if (!data.length) return
-      internalExpandedRowKeys.value = collectTableTreeExpandableKeys(data, {
-        childrenField: treeChildrenField.value,
-        isLeafField: treeIsLeafField.value,
-        lazy: treeLazy.value,
-        rowKey: read(options.rowKey),
-      })
-      treeExpandAllSeeded.value = true
-    },
-    { immediate: true },
-  )
-
-  /**
-   * 渲染用 entry 流水线：
-   * - 树表：buildTableTreeEntries
-   * - 普通：buildTableEntries（sort/filter/group）再 injectExpandRows
-   */
-  const tableEntries = computed(() => {
-    const tree = read(options.treeConfig)
-    const columns = read(options.displayColumns)
-    const data = read(options.data)
-    const rowKey = read(options.rowKey)
-    if (tree) {
-      return buildTableTreeEntries(data, columns, expandedKeySet.value, {
-        tree,
-        rowKey,
-        sort: sortState.value,
-        sorts: sortsState.value,
-        multiSort: read(options.multiSort),
-        filterText: read(options.filterText),
-        filterKeys: read(options.filterKeys),
-        columnFilters: read(options.columnFilters),
-        remoteSort: read(options.remoteSort),
-      })
-    }
-    return injectExpandRows(
-      buildTableEntries(data, columns, {
-        sort: sortState.value,
-        sorts: sortsState.value,
-        multiSort: read(options.multiSort),
-        filterText: read(options.filterText),
-        filterKeys: read(options.filterKeys),
-        columnFilters: read(options.columnFilters),
-        groupBy: read(options.groupBy),
-        groupLabel: read(options.groupLabel),
-        remoteSort: read(options.remoteSort),
-      }),
-      expandedKeySet.value,
-      rowKey,
-      read(options.rowExpandable),
-    )
-  })
-
-  /**
-   * 单次遍历 tableEntries，产出 dataRows / viewRows / selectableRowKeys / rowKeyByIndex。
-   * 不依赖 selectedKeySet，避免选中变化触发全量重遍历。
-   */
-  const rowDerivedState = computed(() => {
-    const rows: Extract<RsTableRowEntry<T>, { type: 'row' }>[] = []
-    const view: T[] = []
-    const selKeys: string[] = []
-    const keyByIndex = new Map<number, string>()
-    const rowKey = read(options.rowKey)
-    const rowSelectable = read(options.rowSelectable)
-    for (const entry of tableEntries.value) {
-      if (entry.type !== 'row') continue
-      rows.push(entry)
-      view.push(entry.row)
-      const key = entry.treeKey ?? resolveRowKey(entry.row, entry.rowIndex, rowKey)
-      keyByIndex.set(entry.rowIndex, key)
-      const disabled = isTableRowDisabled(entry.row)
-      if (!disabled && (rowSelectable ? rowSelectable(entry.row, entry.rowIndex) : true)) {
-        selKeys.push(key)
-      }
-    }
-    return { rows, view, selKeys, keyByIndex }
-  })
-
-  const dataRows = computed(() => rowDerivedState.value.rows)
-  const selectableRowKeys = computed(() => rowDerivedState.value.selKeys)
-  /** rowIndex → rowKey，供模板热路径 O(1) 查询 */
-  const rowKeyByIndex = computed(() => rowDerivedState.value.keyByIndex)
-  /** 当前筛选/排序后的业务行（不含 group/expand 伪行），与 dataRows 同趟产出 */
-  const viewRows = computed(() => rowDerivedState.value.view)
-
-  /** 当前已选行对象（依赖 dataRows + selectedKeySet；选中变化不重扫 tableEntries） */
-  const selectedRows = computed<T[]>(() => {
-    const keySet = selectedKeySet.value
-    const keyMap = rowKeyByIndex.value
-    const out: T[] = []
-    for (const entry of dataRows.value) {
-      if (keySet.has(keyMap.get(entry.rowIndex) ?? '')) out.push(entry.row)
-    }
-    return out
-  })
-
-  const selectAllState = computed(() =>
-    resolveSelectAllState(selectedRowKeys.value, selectableRowKeys.value),
-  )
-
-  return {
-    internalSort,
-    internalSorts,
-    internalSelectedRowKeys,
-    internalExpandedRowKeys,
-    treeLoadingKeys,
-    isSortControlled,
-    sortState,
-    isSortsControlled,
-    sortsState,
-    isSelectionControlled,
-    selectedRowKeys,
-    selectedKeySet,
-    isExpandedControlled,
-    expandedRowKeys,
-    expandedKeySet,
-    treeMode,
-    detailExpandable,
-    treeChildrenField,
-    treeIsLeafField,
-    treeLazy,
-    treeCheckStrictly,
-    treeIndentPx,
-    treeExpandColumnKey,
-    treeFixExpandColumn,
-    treeLoadingKeySet,
-    tableTreeNodeIndex,
-    tableEntries,
-    dataRows,
-    selectableRowKeys,
-    rowKeyByIndex,
-    selectedRows,
-    selectAllState,
-    viewRows,
-  }
-}
-
-/** useRsTableEngine 返回值类型 */
-export type RsTableEngineApi<T extends RsTableRowData> = ReturnType<typeof useRsTableEngine<T>>