niuma-ui 1.1.11 → 1.2.0

package/src/composables/useRsTableGridKeyboard.ts

@@ -1,123 +0,0 @@
-/**
- * RsTable ARIA Grid 键盘漫游（与编辑键盘解耦）。
- *
- * - 始终可在壳层焦点下移动 focusCell（只读表也可用）
- * - 编辑中 / 表单控件内不抢键
- * - 箭头 / Home / End / Ctrl+Home|End / PageUp|PageDown
- * - 移动后将焦点格 scrollIntoView（nearest）
- */
-
-import { nextTick, type Ref } from 'vue'
-import type { useTableEdit } from './useTableEdit'
-import {
-  navigateGridCell,
-  resolveGridNavDirection,
-  type RsTableGridCellRef,
-} from '../components/table/rs-table-grid-nav'
-import type { RsTableColumn, RsTableRowData, RsTableRowEntry } from '../components/table-utils'
-
-type TableEditApi = ReturnType<typeof useTableEdit>
-
-export interface UseRsTableGridKeyboardOptions<T extends RsTableRowData> {
-  tableEdit: TableEditApi
-  /** 默认 true；可关以兼容旧行为 */
-  enabled?: () => boolean
-  dataRows: () => Array<Extract<RsTableRowEntry<T>, { type: 'row' }>>
-  rowKeyFor: (entry: Extract<RsTableRowEntry<T>, { type: 'row' }>) => string
-  /** 可见数据列（与虚拟列切片一致） */
-  colKeys: () => string[]
-  displayColumns?: () => RsTableColumn<T>[]
-  applyRowClickHighlight: (rowKey: string) => void
-  /** PageUp/Down 跨越行数，默认 10 */
-  pageSize?: () => number
-  /** 滚动容器：用于焦点格滚入视口 */
-  scrollContainerRef?: Ref<HTMLElement | null | undefined>
-}
-
-function escapeAttr(value: string): string {
-  if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {
-    return CSS.escape(value)
-  }
-  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
-}
-
-function scrollFocusCellIntoView(
-  container: HTMLElement | null | undefined,
-  cell: RsTableGridCellRef,
-): void {
-  if (!container) return
-  const selector = `tr[data-row-key="${escapeAttr(cell.rowKey)}"] td[data-col-key="${escapeAttr(cell.colKey)}"]`
-  const el = container.querySelector(selector) as HTMLElement | null
-  // jsdom 无 scrollIntoView；浏览器 / happy-dom 才滚
-  if (el && typeof el.scrollIntoView === 'function') {
-    el.scrollIntoView({ block: 'nearest', inline: 'nearest' })
-  }
-}
-
-/**
- * 网格键盘漫游 API。
- */
-export function useRsTableGridKeyboard<T extends RsTableRowData>(
-  options: UseRsTableGridKeyboardOptions<T>,
-) {
-  function buildRows(): Array<{ rowKey: string; rowIndex: number }> {
-    return options.dataRows().map((entry) => ({
-      rowKey: options.rowKeyFor(entry),
-      rowIndex: entry.rowIndex,
-    }))
-  }
-
-  function resolveColKeys(): string[] {
-    const keys = options.colKeys()
-    if (keys.length) return keys
-    return (options.displayColumns?.() ?? []).map((c) => c.key)
-  }
-
-  /**
-   * 处理网格导航键。已处理返回 true（调用方应停止后续编辑键逻辑中的箭头分支）。
-   */
-  function onGridKeydown(event: KeyboardEvent): boolean {
-    if (options.enabled && !options.enabled()) return false
-    if (options.tableEdit.editingCell.value) return false
-
-    const target = event.target as HTMLElement | null
-    if (target?.closest('input, textarea, select, [contenteditable="true"]')) {
-      return false
-    }
-
-    const direction = resolveGridNavDirection(event)
-    if (!direction) return false
-
-    const rows = buildRows()
-    const colKeys = resolveColKeys()
-    if (!rows.length || !colKeys.length) return false
-
-    const focus = options.tableEdit.focusCell.value
-    const current: RsTableGridCellRef | null = focus
-      ? {
-          rowKey: focus.rowKey,
-          colKey: focus.colKey,
-          rowIndex: focus.rowIndex,
-        }
-      : null
-
-    const next = navigateGridCell(
-      rows,
-      colKeys,
-      current,
-      direction,
-      options.pageSize?.() ?? 10,
-    )
-    if (!next) return false
-
-    event.preventDefault()
-    options.tableEdit.setFocusCell(next)
-    options.applyRowClickHighlight(next.rowKey)
-    void nextTick(() => {
-      scrollFocusCellIntoView(options.scrollContainerRef?.value, next)
-    })
-    return true
-  }
-
-  return { onGridKeydown }
-}

package/src/composables/useRsTableHeadless.ts

@@ -1,145 +0,0 @@
-/**
- * RsTable 无头驱动入口（无模板也能跑 Engine / Features / Api）。
- *
- * 适用：服务端预计算、自定义渲染器、图表只消费 snapshot。
- * 不含列宽 DOM / 右键 / 编辑交互（那些依赖视图壳）。
- *
- * 多表：每次调用产生独立 Core + FeatureHost；互不共享状态。
- * 唯一全局点是 RsTableModuleRegistry（显式 register 才会影响所有实例）。
- */
-
-import type { Ref } from 'vue'
-import type { RsTableColumn, RsTableRowData, RsTableRowKey } from '../components/table-utils'
-import type { RsTableFeature } from '../components/table/table-features'
-import { useRsTableCore, type UseRsTableCoreOptions } from './useRsTableCore'
-
-export interface UseRsTableHeadlessOptions<T extends RsTableRowData> {
-  columns: Ref<RsTableColumn<T>[]> | (() => RsTableColumn<T>[])
-  data: Ref<T[]> | (() => T[])
-  rowKey?: RsTableRowKey<T> | (() => RsTableRowKey<T> | undefined)
-  selectable?: boolean
-  features?: RsTableFeature<T>[] | (() => RsTableFeature<T>[] | undefined)
-  /** 最小 emit 桩；受控同步时可传入 */
-  emit?: UseRsTableCoreOptions<T>['emit']
-}
-
-function readRefOrGetter<T>(source: Ref<T> | (() => T)): () => T {
-  return typeof source === 'function' ? (source as () => T) : () => (source as Ref<T>).value
-}
-
-/**
- * 无头表格：复用 useRsTableCore（已含 Feature 绑定），再装配 Api。
- */
-export function useRsTableHeadless<T extends RsTableRowData>(
-  options: UseRsTableHeadlessOptions<T>,
-) {
-  const getColumns = readRefOrGetter(options.columns)
-  const getData = readRefOrGetter(options.data)
-  const getRowKey = (): RsTableRowKey<T> | undefined => {
-    const key = options.rowKey
-    if (key == null) return undefined
-    if (typeof key === 'string') return key
-    // 无参函数视为配置 getter；带 row 参数的视为字段访问器
-    if (typeof key === 'function' && key.length === 0) {
-      return (key as () => RsTableRowKey<T> | undefined)()
-    }
-    return key as RsTableRowKey<T>
-  }
-  const getFeatures = () =>
-    typeof options.features === 'function' ? options.features() : options.features
-
-  const noopEmit = ((() => undefined) as unknown) as UseRsTableCoreOptions<T>['emit']
-
-  const core = useRsTableCore<T>({
-    columns: getColumns,
-    data: getData,
-    rowKey: getRowKey,
-    compact: () => false,
-    size: () => 'md',
-    columnOrder: () => undefined,
-    defaultColumnOrder: [],
-    columnFilters: () => undefined,
-    defaultColumnFilters: {},
-    initialColumnWidths: () => undefined,
-    resizable: () => false,
-    columnLayout: () => 'auto',
-    sort: () => undefined,
-    defaultSort: null,
-    sorts: () => undefined,
-    defaultSorts: [],
-    multiSort: () => false,
-    remoteSort: () => false,
-    filterText: () => undefined,
-    filterKeys: () => undefined,
-    groupBy: () => undefined,
-    groupLabel: () => undefined,
-    treeConfig: () => undefined,
-    expandable: () => false,
-    rowExpandable: () => undefined,
-    selectedRowKeys: () => undefined,
-    defaultSelectedRowKeys: [],
-    expandedRowKeys: () => undefined,
-    defaultExpandedRowKeys: [],
-    rowSelectable: () => undefined,
-    height: () => 320,
-    layoutActive: () => true,
-    viewKey: () => undefined,
-    virtual: () => false,
-    virtualAutoThreshold: () => 50,
-    fill: () => false,
-    infinite: () => false,
-    virtualOnInfinite: () => true,
-    overscan: () => 4,
-    expandRowHeight: () => undefined,
-    rowHeight: () => undefined,
-    selectable: () => Boolean(options.selectable),
-    editable: () => false,
-    contextMenu: () => false,
-    summaryFeatureEnabled: () => false,
-    features: getFeatures,
-    emit: options.emit ?? noopEmit,
-  })
-
-  const api = core.tableSurface.createApi(
-    {
-      getRowByKey: (rowKey) => {
-        const entry = core.dataRows.value.find(
-          (item) => core.rowKeyByIndex.value.get(item.rowIndex) === rowKey,
-        )
-        return entry?.row
-      },
-      getRowByIndex: (index) =>
-        core.dataRows.value.find((item) => item.rowIndex === index)?.row,
-      getColumnValues: () => [],
-      getCellValue: () => undefined,
-      getViewRows: () => core.viewRows.value,
-      getSelectedRows: () => core.selectedRows.value,
-      getSelectedRowKeys: () => [...core.selectedRowKeys.value],
-      getAnalyticsSnapshot: () => core.analyticsSource.getSnapshot(),
-      subscribeAnalytics: (listener) => core.analyticsSource.subscribe(listener),
-      getHighlightedRowKey: () => undefined,
-      setHighlightedRowKey: () => undefined,
-      cancelCellEdit: () => undefined,
-      cancelAllEdits: () => undefined,
-      getDirtyCellKeys: () => [],
-      getCellError: () => undefined,
-      setCellError: () => undefined,
-      stageCell: () => undefined,
-      rejectRowEdit: () => undefined,
-      undoEdit: () => undefined,
-      redoEdit: () => undefined,
-      commitRowEdits: () => undefined,
-      rollbackRowEdits: () => undefined,
-      getToolbarItems: () => core.tableSurface.getToolbarItems(),
-      getOverlayContributions: () => core.tableSurface.getOverlayContributions(),
-    },
-    { provide: false },
-  )
-
-  return {
-    api,
-    core,
-    getToolbarItems: () => core.tableSurface.getToolbarItems(),
-    getOverlayContributions: () => core.tableSurface.getOverlayContributions(),
-  }
-}

package/src/composables/useRsTableInteraction.ts

@@ -1,433 +0,0 @@
-/**
- * RsTable 行/列交互：排序点击、列拖拽排序、行选/展开、行拖拽封装。
- *
- * 性能约定：
- * - 不引入对 data 的 deep watch
- * - rowKeyFor 走 Engine 的 rowKeyByIndex 缓存，避免热路径重复 resolve
- */
-
-import { ref, type ComputedRef, type Ref } from 'vue'
-import {
-  createTableRowDragHandlers,
-  createTableRowDragState,
-  type RsTableRowDragTrigger,
-  type RsTableRowDropMode,
-} from '../components/table-drag'
-import {
-  getSortOrderForKey,
-  getSortPriorityForKey,
-  getTableTreeChildren,
-  hasTableTreeChildren,
-  isTableRowDisabled,
-  reorderColumnKeys,
-  resolveRowKey,
-  resolveTableTreeCheckState,
-  selectRowKeys,
-  selectRowKeysByClick,
-  toggleExpandedRowKeys,
-  toggleMultiSortState,
-  toggleSelectAll,
-  toggleSortState,
-  toggleTableTreeCheck,
-  type RsTableColumn,
-  type RsTableRowData,
-  type RsTableRowEntry,
-  type RsTableRowKey,
-  type RsTableSelectionType,
-  type RsTableSortOrder,
-  type RsTableSortState,
-  type RsTableTreeConfig,
-  type RsTableTreeNodeIndex,
-  type RsTableRowDropPosition,
-} from '../components/table-utils'
-
-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
-}
-
-export interface UseRsTableInteractionOptions<T extends RsTableRowData> {
-  multiSort: () => boolean
-  maxSort: () => number | undefined
-  columnDraggable: () => boolean
-  selectable: () => boolean
-  selectionType: () => RsTableSelectionType
-  rowSelectable?: (row: T, index: number) => boolean
-  rowDraggable: () => boolean
-  rowDragTrigger: () => RsTableRowDragTrigger
-  rowDropMode: () => RsTableRowDropMode
-  rowDraggableWhen?: (row: T, index: number) => boolean
-  rowDropTargetWhen?: (row: T, index: number) => boolean
-  canRowDrop?: (dragKeys: string[], dropKey: string) => boolean
-  rowKey: () => RsTableRowKey<T> | undefined
-  rowKeyByIndex: () => Map<number, string>
-  selectedRowKeys: {
-    get: () => string[]
-    set: (keys: string[]) => void
-  }
-  selectedKeySet: () => Set<string>
-  selectableRowKeys: () => string[]
-  selectAllState: () => 'checked' | 'indeterminate' | 'unchecked'
-  expandedRowKeys: {
-    get: () => string[]
-    set: (keys: string[]) => void
-  }
-  expandedKeySet: () => Set<string>
-  treeMode: () => boolean
-  treeCheckStrictly: () => boolean
-  treeLazy: () => boolean
-  treeChildrenField: () => string
-  treeIsLeafField: () => string
-  treeLoadingKeys: {
-    get: () => string[]
-    set: (keys: string[]) => void
-  }
-  treeLoadingKeySet: () => Set<string>
-  tableTreeNodeIndex: () => Map<string, RsTableTreeNodeIndex> | null
-  treeConfig: () => RsTableTreeConfig<T> | undefined
-  expandable: () => boolean
-  rowExpandable?: (row: T, index: number) => boolean
-  sortState: {
-    get: () => RsTableSortState | null
-    set: (value: RsTableSortState | null) => void
-  }
-  sortsState: {
-    get: () => RsTableSortState[]
-    set: (value: RsTableSortState[]) => void
-  }
-  columnOrderState: {
-    get: () => string[]
-    set: (value: string[]) => void
-  }
-  /** 行选时若正在编辑则不改选中 */
-  isEditingAny: () => boolean
-  applyRowClickHighlight: (rowKey: string) => void
-  onRowClickEmit: (row: T, index: number) => void
-  onRowDblclickEmit: (row: T, index: number) => void
-  onRowDragStartEmit: (dragKeys: string[], event: DragEvent) => void
-  onRowDropEmit: (dragKeys: string[], dropKey: string, position: RsTableRowDropPosition) => void
-}
-
-/**
- * 表格交互 API（排序 / 列拖 / 行选展开 / 行拖）。
- */
-export function useRsTableInteraction<T extends RsTableRowData>(
-  options: UseRsTableInteractionOptions<T>,
-) {
-  const dragColumnKey = ref<string | null>(null)
-  const dropColumnKey = ref<string | null>(null)
-  const selectionAnchorKey = ref<string | null>(null)
-  const rowDragState = createTableRowDragState()
-  const { dragRowKeys, dropRowTargetKey, dropRowPosition } = rowDragState
-
-  function rowKeyFor(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): string {
-    return (
-      options.rowKeyByIndex().get(entry.rowIndex) ??
-      entry.treeKey ??
-      resolveRowKey(entry.row, entry.rowIndex, options.rowKey())
-    )
-  }
-
-  function sortOrderFor(key: string): RsTableSortOrder {
-    if (options.multiSort()) return getSortOrderForKey(options.sortsState.get(), key)
-    const sort = options.sortState.get()
-    return sort?.key === key ? sort.order : null
-  }
-
-  function sortPriorityFor(key: string): number {
-    if (!options.multiSort()) return 0
-    return getSortPriorityForKey(options.sortsState.get(), key)
-  }
-
-  function sortIconName(key: string): string {
-    const order = sortOrderFor(key)
-    if (order === 'asc') return 'arrow-up'
-    if (order === 'desc') return 'arrow-down'
-    return 'arrow-up-down'
-  }
-
-  function onHeaderClick(column: RsTableColumn<T>): void {
-    if (!column.sortable) return
-    if (options.multiSort()) {
-      options.sortsState.set(
-        toggleMultiSortState(options.sortsState.get(), column.key, options.maxSort()),
-      )
-      return
-    }
-    options.sortState.set(toggleSortState(options.sortState.get(), column.key))
-  }
-
-  function onColumnDragStart(key: string, event: DragEvent): void {
-    if (!options.columnDraggable()) return
-    dragColumnKey.value = key
-    dropColumnKey.value = null
-    if (!event.dataTransfer) return
-    event.dataTransfer.setData('text/plain', key)
-    event.dataTransfer.effectAllowed = 'move'
-  }
-
-  function onColumnDragOver(key: string, event: DragEvent): void {
-    if (!options.columnDraggable() || !dragColumnKey.value) return
-    if (dragColumnKey.value === key) {
-      if (dropColumnKey.value !== null) dropColumnKey.value = null
-      return
-    }
-    event.preventDefault()
-    if (dropColumnKey.value !== key) dropColumnKey.value = key
-  }
-
-  function onColumnDrop(key: string, event: DragEvent): void {
-    if (!options.columnDraggable() || !dragColumnKey.value) return
-    event.preventDefault()
-    if (dragColumnKey.value === key) return
-    options.columnOrderState.set(
-      reorderColumnKeys(options.columnOrderState.get(), dragColumnKey.value, key),
-    )
-    dragColumnKey.value = null
-    dropColumnKey.value = null
-  }
-
-  function onColumnDragEnd(): void {
-    dragColumnKey.value = null
-    dropColumnKey.value = null
-  }
-
-  const isRowSelection = () =>
-    options.selectable() && options.selectionType() === 'row'
-
-  function canSelectRow(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    if (isTableRowDisabled(entry.row)) return false
-    return options.rowSelectable ? options.rowSelectable(entry.row, entry.rowIndex) : true
-  }
-
-  function isRowSelected(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    const key = rowKeyFor(entry)
-    const index = options.tableTreeNodeIndex()
-    if (index && !options.treeCheckStrictly()) {
-      return resolveTableTreeCheckState(key, options.selectedKeySet(), index, false) === 'checked'
-    }
-    return options.selectedKeySet().has(key)
-  }
-
-  function isRowIndeterminate(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    const index = options.tableTreeNodeIndex()
-    if (!index || options.treeCheckStrictly()) return false
-    return (
-      resolveTableTreeCheckState(rowKeyFor(entry), options.selectedKeySet(), index, false) ===
-      'indeterminate'
-    )
-  }
-
-  function onToggleRow(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): void {
-    if (!canSelectRow(entry)) return
-    const key = rowKeyFor(entry)
-    const index = options.tableTreeNodeIndex()
-    if (index && !options.treeCheckStrictly() && options.selectionType() !== 'radio') {
-      options.selectedRowKeys.set(
-        toggleTableTreeCheck(key, options.selectedKeySet(), index, false),
-      )
-      return
-    }
-    options.selectedRowKeys.set(
-      selectRowKeys(options.selectedRowKeys.get(), key, options.selectionType()),
-    )
-  }
-
-  function onToggleSelectAll(): void {
-    const select = options.selectAllState() !== 'checked'
-    options.selectedRowKeys.set(
-      toggleSelectAll(options.selectedRowKeys.get(), options.selectableRowKeys(), select),
-    )
-  }
-
-  function canExpandRow(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    if (options.treeMode()) {
-      if (entry.hasChildren != null) return entry.hasChildren
-      return hasTableTreeChildren(entry.row, {
-        childrenField: options.treeChildrenField(),
-        isLeafField: options.treeIsLeafField(),
-        lazy: options.treeLazy(),
-      })
-    }
-    if (!options.expandable()) return false
-    if (options.rowExpandable) return options.rowExpandable(entry.row, entry.rowIndex)
-    return true
-  }
-
-  function isRowExpanded(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    return options.expandedKeySet().has(rowKeyFor(entry))
-  }
-
-  function treeDepthOf(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): number {
-    return entry.depth ?? 0
-  }
-
-  async function onToggleExpand(
-    entry: Extract<RsTableRowEntry<T>, { type: 'row' }>,
-  ): Promise<void> {
-    if (!canExpandRow(entry)) return
-    const key = rowKeyFor(entry)
-    const expanding = !options.expandedKeySet().has(key)
-    const tree = options.treeConfig()
-
-    if (
-      options.treeMode() &&
-      expanding &&
-      options.treeLazy() &&
-      tree?.loadData &&
-      getTableTreeChildren(entry.row, options.treeChildrenField()).length === 0
-    ) {
-      if (options.treeLoadingKeySet().has(key)) return
-      options.treeLoadingKeys.set([...options.treeLoadingKeys.get(), key])
-      try {
-        const loaded = await tree.loadData(entry.row, key)
-        if (Array.isArray(loaded)) {
-          ;(entry.row as Record<string, unknown>)[options.treeChildrenField()] = loaded
-        }
-      } finally {
-        options.treeLoadingKeys.set(options.treeLoadingKeys.get().filter((item) => item !== key))
-      }
-    }
-
-    options.expandedRowKeys.set(toggleExpandedRowKeys(options.expandedRowKeys.get(), key))
-  }
-
-  function onRowClick(entry: RsTableRowEntry<T>, event?: MouseEvent): void {
-    if (entry.type !== 'row') return
-    const rowKey = rowKeyFor(entry)
-    if (isRowSelection() && canSelectRow(entry) && !options.isEditingAny()) {
-      const toggle = Boolean(event && (event.ctrlKey || event.metaKey))
-      const range = Boolean(event?.shiftKey)
-      options.selectedRowKeys.set(
-        selectRowKeysByClick(options.selectedRowKeys.get(), rowKey, {
-          toggle,
-          range,
-          orderedKeys: options.selectableRowKeys(),
-          anchorKey: selectionAnchorKey.value,
-        }),
-      )
-      if (!range) selectionAnchorKey.value = rowKey
-      if (typeof window !== 'undefined') {
-        window.getSelection()?.removeAllRanges()
-      }
-    }
-    options.applyRowClickHighlight(rowKey)
-    options.onRowClickEmit(entry.row, entry.rowIndex)
-  }
-
-  function onRowSelectMouseDown(event: MouseEvent): void {
-    if (!isRowSelection()) return
-    if (event.shiftKey || event.ctrlKey || event.metaKey) {
-      event.preventDefault()
-    }
-  }
-
-  function onRowDblclick(entry: RsTableRowEntry<T>, _event?: MouseEvent): void {
-    if (entry.type !== 'row') return
-    options.onRowDblclickEmit(entry.row, entry.rowIndex)
-  }
-
-  const rowDrag = createTableRowDragHandlers<T>({
-    state: rowDragState,
-    getRowDraggable: () => options.rowDraggable(),
-    getRowDragTrigger: () => options.rowDragTrigger(),
-    getRowDropMode: () => options.rowDropMode(),
-    rowDraggableWhen: options.rowDraggableWhen,
-    rowDropTargetWhen: options.rowDropTargetWhen,
-    canRowDrop: options.canRowDrop,
-    rowKeyFor: (row, index) => resolveRowKey(row, index, options.rowKey()),
-    isRowDisabled: isTableRowDisabled,
-    getSelectedKeys: () => options.selectedRowKeys.get(),
-    onDragStart: (dragKeys, event) => options.onRowDragStartEmit(dragKeys, event),
-    onDrop: (dragKeys, dropKey, position) =>
-      options.onRowDropEmit(dragKeys, dropKey, position),
-  })
-
-  function onRowDragStart(
-    entry: Extract<RsTableRowEntry<T>, { type: 'row' }>,
-    event: DragEvent,
-  ): void {
-    rowDrag.onRowDragStart(entry.row, entry.rowIndex, event)
-  }
-
-  function onRowDragOver(
-    entry: Extract<RsTableRowEntry<T>, { type: 'row' }>,
-    event: DragEvent,
-  ): void {
-    rowDrag.onRowDragOver(entry.row, entry.rowIndex, event)
-  }
-
-  function onRowDragLeave(event: DragEvent): void {
-    rowDrag.onRowDragLeave(event)
-  }
-
-  function onRowDrop(
-    entry: Extract<RsTableRowEntry<T>, { type: 'row' }>,
-    event: DragEvent,
-  ): void {
-    rowDrag.onRowDrop(entry.row, entry.rowIndex, event)
-  }
-
-  function onRowDragEnd(): void {
-    rowDrag.onRowDragEnd()
-  }
-
-  function isRowDropTarget(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    return rowDrag.isRowDropTarget(rowKeyFor(entry))
-  }
-
-  function isRowDragging(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    return rowDrag.isRowDragging(rowKeyFor(entry))
-  }
-
-  function canDragRow(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    return rowDrag.canDragRow(entry.row, entry.rowIndex)
-  }
-
-  function isRowDragByRow(entry: Extract<RsTableRowEntry<T>, { type: 'row' }>): boolean {
-    return options.rowDraggable() && options.rowDragTrigger() === 'row' && canDragRow(entry)
-  }
-
-  return {
-    dragColumnKey,
-    dropColumnKey,
-    selectionAnchorKey,
-    dragRowKeys,
-    dropRowTargetKey,
-    dropRowPosition,
-    rowKeyFor,
-    sortOrderFor,
-    sortPriorityFor,
-    sortIconName,
-    onHeaderClick,
-    onColumnDragStart,
-    onColumnDragOver,
-    onColumnDrop,
-    onColumnDragEnd,
-    canSelectRow,
-    isRowSelected,
-    isRowIndeterminate,
-    onToggleRow,
-    onToggleSelectAll,
-    canExpandRow,
-    isRowExpanded,
-    treeDepthOf,
-    onToggleExpand,
-    onRowClick,
-    onRowSelectMouseDown,
-    onRowDblclick,
-    onRowDragStart,
-    onRowDragOver,
-    onRowDragLeave,
-    onRowDrop,
-    onRowDragEnd,
-    isRowDropTarget,
-    isRowDragging,
-    canDragRow,
-    isRowDragByRow,
-  }
-}
-
-export type RsTableInteractionApi<T extends RsTableRowData> = ReturnType<
-  typeof useRsTableInteraction<T>
->