9C: Row selection support for DuckDB and server backends

- Add _reactable_rowid (0-based) column to data before serialization for
  stable row identification across pages
- Extract _reactable_rowid into __state = { id, index } for flat rows in
  DuckDB, data frame, and V8 backends
- Add __state with group IDs for grouped rows in DuckDB backend
- Extend getRowId in Reactable.js to check useDuckDB in addition to
  useServerData
- Remove selectedRowIds from V8 server useEffect deps to prevent
  unnecessary re-fetches on selection click
- Remove row selection warning for DuckDB backend
- Delete backendDt and remove data.table from DESCRIPTION
- Fix S3 method param order (searchMethod) to match generic
- Add .claude to .Rbuildignore

Author: glin

.Rbuildignore

@@ -20,3 +20,4 @@
 ^srcjs$
 ^vignettes$
 ^webpack\.config.*\.js$
+^\.claude$

DESCRIPTION

@@ -39,7 +39,6 @@ Suggests:
     arrow,
     covr,
     crosstalk,
-    data.table,
     DBI,
     duckdb,
     dplyr,

NAMESPACE

@@ -3,16 +3,13 @@
 S3method(as.tags,reactable)
 S3method(reactableServerData,default)
 S3method(reactableServerData,reactable_backendDf)
-S3method(reactableServerData,reactable_backendDt)
 S3method(reactableServerData,reactable_backendDuckdb)
 S3method(reactableServerData,reactable_backendV8)
 S3method(reactableServerInit,default)
-S3method(reactableServerInit,reactable_backendDt)
 S3method(reactableServerInit,reactable_backendDuckdb)
 S3method(reactableServerInit,reactable_backendV8)
 export(JS)
 export(backendDf)
-export(backendDt)
 export(backendDuckDB)
 export(backendV8)
 export(colDef)

R/backend-df.R

@@ -25,16 +25,19 @@ reactableServerData.reactable_backendDf <- function(
   sortBy = NULL,
   filters = NULL,
   searchValue = NULL,
+  searchMethod = NULL,
   groupBy = NULL,
   pagination = NULL,
   paginateSubRows = NULL,
   # Unused/unimplemented props
   selectedRowIds = NULL,
   expanded = NULL,
-  searchMethod = NULL,
   ...
 ) {
 
+  # Add 0-based row IDs for stable row identification across pages
+  data[["_reactable_rowid"]] <- seq_len(nrow(data)) - 1L
+
   # Column filters - simple text match for now
   if (length(filters) > 0) {
     data <- dfFilter(data, filters)
@@ -191,6 +194,15 @@ dataFrame <- function(...) {
 }
 
 dfPaginate <- function(df, pageIndex = 0, pageSize = NULL) {
+  # Extract _reactable_rowid into __state for stable row identification (flat rows only)
+  if ("_reactable_rowid" %in% colnames(df) && !"__state" %in% colnames(df)) {
+    rowids <- df[["_reactable_rowid"]]
+    df[["__state"]] <- lapply(rowids, function(rid) {
+      list(id = as.character(rid), index = as.integer(rid))
+    })
+    df[["_reactable_rowid"]] <- NULL
+  }
+
   if (is.null(pageSize)) {
     return(resolvedData(df, rowCount = nrow(df)))
   }

R/backend-dt.R

@@ -104,6 +104,8 @@ reactableServerInit.reactable_backendDuckdb <- function(x, data = NULL, columns
   }
 
   con <- DBI::dbConnect(duckdb::duckdb())
+  # Add 0-based row IDs for stable row identification across pages
+  data[["_reactable_rowid"]] <- seq_len(nrow(data)) - 1L
   # Zero-copy registration - DuckDB reads directly from R data frame memory
   duckdb::duckdb_register(con, "reactable_data", data)
   x$private$con <- con
@@ -120,13 +122,13 @@ reactableServerData.reactable_backendDuckdb <- function(
   sortBy = NULL,
   filters = NULL,
   searchValue = NULL,
+  searchMethod = NULL,
   groupBy = NULL,
   pagination = NULL,
   paginateSubRows = NULL,
   # Unused/unimplemented props
   selectedRowIds = NULL,
   expanded = NULL,
-  searchMethod = NULL,
   ...
 ) {
   con <- x$private$con
@@ -152,6 +154,15 @@ reactableServerData.reactable_backendDuckdb <- function(
   countResult <- DBI::dbGetQuery(con, query$countSql, params = query$params)
   rowCount <- countResult$n
 
+  # Extract _reactable_rowid into __state for stable row identification
+  if ("_reactable_rowid" %in% colnames(page)) {
+    rowids <- page[["_reactable_rowid"]]
+    page[["__state"]] <- lapply(rowids, function(rid) {
+      list(id = as.character(rid), index = as.integer(rid))
+    })
+    page[["_reactable_rowid"]] <- NULL
+  }
+
   resolvedData(page, rowCount = rowCount)
 }
 
@@ -241,9 +252,18 @@ duckdbGroupedQuery <- function(con, columns, filters, searchValue, sortBy,
         subRowsList[[i]] <- subResult
       }
     } else {
-      # Leaf level — fetch individual rows
+      # Leaf level -- fetch individual rows
       subQuery <- buildDuckdbSubRowSql("reactable_data", baseWhere, childFilters, sortBy)
-      subRowsList[[i]] <- DBI::dbGetQuery(con, subQuery$sql, params = subQuery$params)
+      subRows <- DBI::dbGetQuery(con, subQuery$sql, params = subQuery$params)
+      # Extract _reactable_rowid into __state for stable row identification
+      if ("_reactable_rowid" %in% colnames(subRows)) {
+        rowids <- subRows[["_reactable_rowid"]]
+        subRows[["__state"]] <- lapply(rowids, function(rid) {
+          list(id = as.character(rid), index = as.integer(rid))
+        })
+        subRows[["_reactable_rowid"]] <- NULL
+      }
+      subRowsList[[i]] <- subRows
     }
 
     # Post-compute aggregates from sub-row data (e.g. frequency)
@@ -257,6 +277,11 @@ duckdbGroupedQuery <- function(con, columns, filters, searchValue, sortBy,
 
   groupData[[".subRows"]] <- subRowsList
 
+  # Add __state with group ID for group header rows
+  groupData[["__state"]] <- lapply(groupValues, function(val) {
+    list(id = paste0(groupCol, ":", val), grouped = TRUE)
+  })
+
   if (depth == 0) {
     resolvedData(groupData, rowCount = rowCount)
   } else {

R/backend-duckdb.R

@@ -130,15 +130,14 @@
 #'   Static rendering is **experimental**, and is not supported for tables
 #'   rendered via [reactableOutput()] in Shiny.
 #' @param server **Deprecated.** Use `backend` instead. Accepts `TRUE` (equivalent
-#'   to `backendV8()`), or a backend string like `"df"`, `"dt"`, `"duckdb"`.
+#'   to `backendV8()`), or a backend string like `"df"`, `"duckdb"`.
 #' @param backend A backend object for data processing. Options:
 #'   \describe{
 #'     \item{[backendDuckDB()]}{DuckDB-powered sorting, filtering, and pagination.
 #'       In static documents (R Markdown, Quarto), DuckDB-WASM runs in the browser.
 #'       In Shiny, the DuckDB R package runs on the server.}
 #'     \item{[backendV8()]}{V8 server-side processing (Shiny only).}
 #'     \item{[backendDf()]}{Pure R data frame operations (Shiny only).}
-#'     \item{[backendDt()]}{data.table operations (Shiny only). Requires the data.table package.}
 #'   }
 #' @param selectionId **Deprecated**. Use [getReactableState()] to get the selected rows
 #'   in Shiny.
@@ -272,7 +271,7 @@ reactable <- function(
 
   if (!is.null(backend)) {
     if (!is.object(backend)) {
-      stop("`backend` must be a backend object created by `backendDuckDB()`, `backendV8()`, `backendDf()`, or `backendDt()`")
+      stop("`backend` must be a backend object created by `backendDuckDB()`, `backendV8()`, or `backendDf()`")
     }
     if (!isFALSE(server)) {
       stop("`backend` and `server` cannot both be specified. Use `backend` instead of `server`.")
@@ -287,7 +286,6 @@ reactable <- function(
       "The `server` argument is deprecated. Use `backend` instead:\n",
       '  backend = backendV8()      # instead of server = TRUE\n',
       '  backend = backendDf()      # instead of server = "df"\n',
-      '  backend = backendDt()      # instead of server = "dt"\n',
       '  backend = backendDuckDB()  # instead of server = "duckdb"',
       call. = FALSE
     )
@@ -297,8 +295,6 @@ reactable <- function(
       backend <- backendV8()
     } else if (identical(server, "df")) {
       backend <- backendDf()
-    } else if (identical(server, "dt")) {
-      backend <- backendDt()
     } else if (identical(server, "duckdb")) {
       backend <- backendDuckDB(mode = "server")
     } else if (is.object(server)) {
@@ -867,10 +863,10 @@ reactable <- function(
               "Use a JS() function instead: reactable(rowStyle = JS(\"function(rowInfo) { ... }\")).",
               call. = FALSE)
     }
-    if (!is.null(selection)) {
-      warning('Row `selection` is not supported with `backendDuckDB()` and will not work correctly.',
-              call. = FALSE)
-    }
+    # Add 0-based row IDs for stable row identification across pages. DuckDB queries
+    # return different rows per page, so page-relative indices (0, 1, 2...) would collide.
+    # The JS side extracts this column and uses it for __state.id and __state.index.
+    data[["_reactable_rowid"]] <- seq_len(nrow(data)) - 1L
 
     arrowData <- serializeArrowIPC(data)
     totalRowCount <- nrow(data)
@@ -908,6 +904,7 @@ reactable <- function(
       firstPageData <- firstPageData[do.call(order, orderArgs), , drop = FALSE]
     }
     firstPageData <- utils::head(firstPageData, defaultPageSize)
+    firstPageData[["_reactable_rowid"]] <- NULL
     data <- toJSON(firstPageData)
     serverRowCount <- totalRowCount
     serverMaxRowCount <- totalRowCount

R/reactable.R

@@ -499,7 +499,6 @@ getServerBackend <- function(backend = NULL) {
   backends <- list(
     v8 = backendV8,
     df = backendDf,
-    dt = backendDt,
     duckdb = backendDuckdbServer
   )