🧪 [Hooks]: Enhance table tests

Author: junerver

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/useCountdown.kt

@@ -49,45 +49,45 @@ private fun useCountdown(options: UseCountdownOptions): CountdownHolder {
     require(leftTime.asBoolean() || targetDate.asBoolean()) {
         "'leftTime' or 'targetDate' must be set"
     }
-    val leftTimeState = useLatestState(leftTime)
-    val targetDateState = useLatestState(targetDate)
-    val target by useState {
-        if (leftTimeState.value.asBoolean()) {
-            currentInstant + leftTimeState.value!!
+    val targetRef = useRef<Instant?>(null)
+    val (timeLeft, setTimeLeft) = useGetState(Duration.ZERO)
+
+    useEffect(leftTime, targetDate) {
+        targetRef.current = if (leftTime.asBoolean()) {
+            currentInstant + leftTime
         } else {
-            targetDateState.value
+            targetDate
         }
+        setTimeLeft(calcLeft(targetRef.current))
     }
-
-    val (timeLeft, setTimeLeft) = useGetState(calcLeft(target))
     val onEndRef by useLatestRef(value = onEnd)
     var pauseRef by useRef(default = {})
     val (resume, pause) = useInterval(
         optionsOf = {
             period = interval
         },
     ) {
-        val targetLeft = calcLeft(target)
+        val targetLeft = calcLeft(targetRef.current)
         setTimeLeft(targetLeft)
         if (targetLeft == Duration.ZERO) {
             pauseRef()
             onEndRef?.invoke()
         }
     }
-    useEffect(targetDate) {
+    useEffect(targetRef.current) {
         resume()
     }
     pauseRef = pause
     useEffect(interval) {
-        if (!target.asBoolean()) {
+        if (!targetRef.current.asBoolean()) {
             setTimeLeft(Duration.ZERO)
             return@useEffect
         }
-        setTimeLeft(calcLeft(target))
+        setTimeLeft(calcLeft(targetRef.current))
         resume()
     }
-    val formatRes = useState { parseDuration(timeLeft.value) }
-    return remember { CountdownHolder(timeLeft, formatRes) }
+    val formatResState = useState(timeLeft.value) { parseDuration(timeLeft.value) }
+    return remember { CountdownHolder(timeLeft, formatResState) }
 }
 
 /**

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/useTimeoutFn.kt

@@ -81,13 +81,16 @@ private class TimeoutFn(private val options: UseTimeoutFnOptions) {
 
         scope.launch {
             isPendingState?.value = true
-            if (options.immediateCallback) {
-                timeoutFn.current(this)
-            } else {
-                delay(interval)
-                timeoutFn.current(this)
+            try {
+                if (options.immediateCallback) {
+                    timeoutFn.current(this)
+                } else {
+                    delay(interval)
+                    timeoutFn.current(this)
+                }
+            } finally {
+                isPendingState?.value = false
             }
-            isPendingState?.value = false
         }.also { timeoutJob = it }
     }
 

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/Table.kt

@@ -4,13 +4,11 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import kotlin.math.ceil
 import xyz.junerver.compose.hooks.createContext
-import xyz.junerver.compose.hooks.useContext
 import xyz.junerver.compose.hooks.usetable.core.ColumnDef
 import xyz.junerver.compose.hooks.usetable.core.Row
 import xyz.junerver.compose.hooks.usetable.state.TableState
+import xyz.junerver.compose.hooks.usetable.features.pagination.PaginationFeature
 
 /**
  * Internal table context for managing table state across components.
@@ -71,7 +69,8 @@ class TableScope<T>(val table: TableHolder<T>) {
     ) {
         val columns by table.columns
         val tableState by table.state
-        content(columns, tableState)
+        val visibleColumns = columns.filter { tableState.columnVisibility.columnVisibility[it.id] != false }
+        content(visibleColumns, tableState)
     }
 
     /**
@@ -103,11 +102,10 @@ class TableScope<T>(val table: TableHolder<T>) {
         val pageIndex = tableState.pagination.pageIndex
         val pageSize = tableState.pagination.pageSize
         val totalRows = rowModel.totalRows
-        
-        // Logic calculation for pagination
-        val pageCount = if (pageSize <= 0) 1 else ceil(totalRows.toDouble() / pageSize).toInt().coerceAtLeast(1)
-        val canNext = pageIndex < pageCount - 1
-        val canPrev = pageIndex > 0
+
+        val pageCount = PaginationFeature.pageCount(totalRows, pageSize)
+        val canNext = PaginationFeature.canNext(pageIndex, pageCount)
+        val canPrev = PaginationFeature.canPrev(pageIndex)
 
         val scope = PaginationScope(
             pageIndex = pageIndex,

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/core/TableFeature.kt

@@ -17,7 +17,7 @@ interface TableFeature<T> {
      * Transform the row model.
      * Now includes [columns] to allow features to look up column definitions (e.g. for sorting/filtering).
      */
-    suspend fun transform(
+    fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/columnSizing/ColumnSizingFeature.kt

@@ -16,7 +16,7 @@ class ColumnSizingFeature<T> : TableFeature<T> {
         // State wiring in Phase 7
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/columnVisibility/ColumnVisibilityFeature.kt

@@ -16,7 +16,7 @@ class ColumnVisibilityFeature<T> : TableFeature<T> {
         // State wiring in Phase 7
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/expansion/ExpansionFeature.kt

@@ -16,7 +16,7 @@ class ExpansionFeature<T> : TableFeature<T> {
         // State wiring will be done in Phase 7 (useTable hook)
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/filtering/FilteringFeature.kt

@@ -16,7 +16,7 @@ class FilteringFeature<T> : TableFeature<T> {
         // TODO: Register state and API
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>
@@ -28,24 +28,24 @@ class FilteringFeature<T> : TableFeature<T> {
             return rows
         }
 
+        val filterableColumns = columns.filter { it.enableFiltering }
+        if (filterableColumns.isEmpty()) {
+            return rows
+        }
+
         return rows.filter { row ->
-            // 1. Column Filters
             val passColumnFilters = columnFilters.all { (colId, filterValue) ->
                 if (filterValue == null) return@all true
-                val column = columns.find { it.id == colId } ?: return@all true
-                
+                val column = filterableColumns.find { it.id == colId } ?: return@all true
+
                 val cellValue = row.getValue(column)
-                // Simple equality check for Phase 1. 
-                // Phase 3 refactor will add FilterFns (includes, equals, etc.)
                 cellValue.toString().contains(filterValue.toString(), ignoreCase = true)
             }
 
             if (!passColumnFilters) return@filter false
 
-            // 2. Global Filter
             if (globalFilter.isNotBlank()) {
-                // Search across all columns
-                return@filter columns.any { column ->
+                return@filter filterableColumns.any { column ->
                     val cellValue = row.getValue(column)
                     cellValue.toString().contains(globalFilter, ignoreCase = true)
                 }

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/grouping/GroupingFeature.kt

@@ -16,7 +16,7 @@ class GroupingFeature<T> : TableFeature<T> {
         // State wiring in Phase 7
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>
@@ -28,15 +28,16 @@ class GroupingFeature<T> : TableFeature<T> {
         val groupColumn = columns.find { it.id == grouping.first() } ?: return rows
 
         val groups = rows.groupBy { row -> row.getValue(groupColumn) }
-        
+
         return groups.map { (groupValue, groupRows) ->
+            val groupKey = groupValue?.toString() ?: "null"
             Row(
-                id = "group-${groupValue.hashCode()}",
+                id = "group-${groupColumn.id}-$groupKey",
                 original = groupRows.first().original,
                 index = 0,
                 depth = 0,
                 subRows = groupRows,
-                metadata = mapOf("isGroupHeader" to true, "groupValue" to groupValue)
+                metadata = mapOf("isGroupHeader" to true, "groupValue" to groupValue, "groupKey" to groupKey)
             )
         }
     }

hooks/src/commonMain/kotlin/xyz/junerver/compose/hooks/usetable/features/pagination/PaginationFeature.kt

@@ -1,40 +1,54 @@
 package xyz.junerver.compose.hooks.usetable.features.pagination
 
 import androidx.compose.runtime.Composable
+import kotlin.math.ceil
+import kotlin.math.min
 import xyz.junerver.compose.hooks.usetable.core.ColumnDef
 import xyz.junerver.compose.hooks.usetable.core.Row
 import xyz.junerver.compose.hooks.usetable.core.TableFeature
 import xyz.junerver.compose.hooks.usetable.core.TableInstance
+import xyz.junerver.compose.hooks.usetable.state.PaginationState
 import xyz.junerver.compose.hooks.usetable.state.TableState
-import kotlin.math.ceil
-import kotlin.math.max
-import kotlin.math.min
 
 class PaginationFeature<T> : TableFeature<T> {
     override val featureId = "pagination"
-    override val priority = 400 // Execute LAST (after filtering & sorting)
+    override val priority = 400
 
     @Composable
     override fun initState(instance: TableInstance<T>) {
-        // In actual hook implementation, we will wire up the state setters here.
-        // For now, we define the transform logic.
     }
 
-    override suspend fun transform(
+    override fun transform(
         rows: List<Row<T>>,
         state: TableState<T>,
         columns: List<ColumnDef<T, *>>
     ): List<Row<T>> {
-        val pageIndex = state.pagination.pageIndex
-        val pageSize = state.pagination.pageSize
-        
-        if (pageSize <= 0) return rows
-
-        val startIndex = pageIndex * pageSize
-        // Boundary check
-        if (startIndex >= rows.size) return emptyList()
-        
-        val endIndex = min(startIndex + pageSize, rows.size)
-        return rows.subList(startIndex, endIndex)
+        return paginate(rows, state.pagination)
+    }
+
+    companion object {
+        fun pageCount(totalRows: Int, pageSize: Int): Int {
+            if (pageSize <= 0) return 1
+            return ceil(totalRows.toDouble() / pageSize).toInt().coerceAtLeast(1)
+        }
+
+        fun canNext(pageIndex: Int, pageCount: Int): Boolean {
+            return pageIndex < pageCount - 1
+        }
+
+        fun canPrev(pageIndex: Int): Boolean {
+            return pageIndex > 0
+        }
+
+        fun <T> paginate(rows: List<Row<T>>, pagination: PaginationState): List<Row<T>> {
+            val pageSize = pagination.pageSize
+            if (pageSize <= 0) return rows
+
+            val startIndex = (pagination.pageIndex * pageSize).coerceAtLeast(0)
+            if (startIndex >= rows.size) return emptyList()
+
+            val endIndex = min(startIndex + pageSize, rows.size)
+            return rows.subList(startIndex, endIndex)
+        }
     }
 }