niuma-ui 1.0.0 → 1.0.2

package/src/composables/useRsTableGridKeyboard.ts

@@ -0,0 +1,123 @@
+/**
+ * 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

@@ -0,0 +1,137 @@
+/**
+ * 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 = () =>
+    typeof options.rowKey === 'function' ? options.rowKey() : options.rowKey
+  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

@@ -0,0 +1,433 @@
+/**
+ * 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>
+>