Merge pull request #10 from utsmannn/feature/grid-scrolling

feat: enhance horizontal grid with snap and caching features

Author: utsmannn

compose-remote-layout-router/src/commonMain/kotlin/com/utsman/composeremote/router/CachedKtorLayoutFetcher.kt

@@ -12,12 +12,12 @@ class CachedKtorLayoutFetcher(
     private val maxCacheSize: Int = 100,
     private val cacheTtlMillis: Long = 15.minutes.inWholeMilliseconds,
 ) : LayoutFetcher {
-    private val cache = ConcurrentHashMap<String, CacheEntry>()
+    private val cache =
+        ConcurrentHashMap<String, CacheEntry>()
 
     private val cacheMutex = Mutex()
 
     override suspend fun fetchLayout(url: String): Result<String> {
-        println("Fetching layout cached from: $url")
         val cachedEntry = cache.get(url)
         if (cachedEntry != null && !isExpired(cachedEntry)) {
             return Result.success(cachedEntry.layout)
@@ -33,38 +33,61 @@ class CachedKtorLayoutFetcher(
                     oldestKey?.let { cache.remove(it) }
                 }
 
-                cache.put(url, CacheEntry(layout, Clock.System.now().toEpochMilliseconds()))
+                cache.put(
+                    url,
+                    CacheEntry(
+                        layout,
+                        Clock.System.now()
+                            .toEpochMilliseconds(),
+                    ),
+                )
             }
         }
 
         return result
     }
 
     override fun fetchLayoutAsFlow(url: String): Flow<ResultLayout<String>> = flow {
-        println("Fetching layout cached from: $url")
         emit(ResultLayout.Loading)
 
         try {
             val cachedEntry = cache.get(url)
-            if (cachedEntry != null && !isExpired(cachedEntry)) {
+            if (cachedEntry != null &&
+                !isExpired(
+                    cachedEntry,
+                )
+            ) {
                 emit(ResultLayout.success(cachedEntry.layout))
                 return@flow
             }
 
-            delegate.fetchLayoutAsFlow(url).collect { result ->
-                if (result is ResultLayout.Success) {
-                    cacheMutex.withLock {
-                        if (cache.size >= maxCacheSize) {
-                            val oldestKey = findOldestEntry()
-                            oldestKey?.let { cache.remove(it) }
+            delegate.fetchLayoutAsFlow(url)
+                .collect { result ->
+                    if (result is ResultLayout.Success) {
+                        cacheMutex.withLock {
+                            if (cache.size >= maxCacheSize) {
+                                val oldestKey =
+                                    findOldestEntry()
+                                oldestKey?.let {
+                                    cache.remove(
+                                        it,
+                                    )
+                                }
+                            }
+
+                            cache.put(
+                                url,
+                                CacheEntry(
+                                    result.data,
+                                    Clock.System.now()
+                                        .toEpochMilliseconds(),
+                                ),
+                            )
                         }
-
-                        cache.put(url, CacheEntry(result.data, Clock.System.now().toEpochMilliseconds()))
                     }
-                }
 
-                emit(result)
-            }
+                    emit(result)
+                }
         } catch (e: Exception) {
             emit(ResultLayout.failure(e))
         }
@@ -110,4 +133,8 @@ class CachedKtorLayoutFetcher(
 fun KtorHttpLayoutFetcher.cached(
     maxCacheSize: Int = 100,
     cacheTtlMillis: Long = 15.minutes.inWholeMilliseconds,
-): CachedKtorLayoutFetcher = CachedKtorLayoutFetcher(this, maxCacheSize, cacheTtlMillis)
+): CachedKtorLayoutFetcher = CachedKtorLayoutFetcher(
+    this,
+    maxCacheSize,
+    cacheTtlMillis,
+)

compose-remote-layout-router/src/commonMain/kotlin/com/utsman/composeremote/router/KtorHttpLayoutFetcher.kt

@@ -9,16 +9,17 @@ import io.ktor.client.statement.HttpResponse
 import io.ktor.client.statement.bodyAsText
 import kotlinx.coroutines.flow.Flow
 
-class KtorHttpLayoutFetcher : LayoutFetcher {
-    private val client = HttpClient {
-        install(Logging) {
-            level = LogLevel.BODY
-        }
-        install(HttpCache)
+val KtorClientDefault = HttpClient {
+    install(Logging) {
+        level = LogLevel.BODY
     }
+    install(HttpCache)
+}
 
+class KtorHttpLayoutFetcher(
+    private val client: HttpClient = KtorClientDefault,
+) : LayoutFetcher {
     override suspend fun fetchLayout(url: String): Result<String> = try {
-        println("Fetching layout from: $url")
         val response: HttpResponse = client.get(url)
         val layoutText = response.bodyAsText()
         Result.success(layoutText)
@@ -27,9 +28,14 @@ class KtorHttpLayoutFetcher : LayoutFetcher {
     }
 
     override fun fetchLayoutAsFlow(url: String): Flow<ResultLayout<String>> = ResultLayout.flow {
-        println("Fetching layout from: $url")
         val response: HttpResponse = client.get(url)
-        response.bodyAsText()
+        val content = response.bodyAsText()
+        if (!content.startsWith("{")) {
+            throw IllegalStateException(
+                "Invalid layout content",
+            )
+        }
+        content
     }
 
     fun close() {

compose-remote-layout-router/src/commonMain/kotlin/com/utsman/composeremote/router/RemoteRouter.kt

@@ -29,7 +29,7 @@ interface RemoteRouter {
     fun reload()
 }
 
-class ResultRemoteRouterImpl(
+internal class ResultRemoteRouterImpl(
     private val fetcher: LayoutFetcher,
     private val scope: CoroutineScope,
 ) : RemoteRouter {

compose-remote-layout-router/src/commonMain/kotlin/com/utsman/composeremote/router/ResultLayout.kt

@@ -65,6 +65,7 @@ sealed class ResultLayout<out T> {
             try {
                 emit(Success(block()))
             } catch (e: Exception) {
+                e.printStackTrace()
                 emit(Failure(e))
             }
         }

compose-remote-layout/src/commonMain/kotlin/com/utsman/composeremote/CacheScrollPosition.kt

@@ -19,12 +19,26 @@ class CacheScrollPosition {
     fun remove(key: String): Int? = map.remove(key)
 
     fun clear() = map.clear()
+}
+
+class CacheScrollOffsetPosition {
+    private val map = mutableMapOf<String, Pair<Int, Int>>()
+
+    fun put(
+        key: String,
+        value: Pair<Int, Int>,
+    ): Pair<Int, Int>? = map.put(key, value)
+
+    fun get(
+        key: String?,
+    ): Pair<Int, Int> = map[key] ?: Pair(0, 0)
+
+    val size get() = map.size
+
+    fun remove(key: String): Pair<Int, Int>? = map.remove(key)
 
-    operator fun plus(other: CacheScrollPosition): CacheScrollPosition {
-        val otherMap = other.map
-        map.putAll(otherMap)
-        return this
-    }
+    fun clear() = map.clear()
 }
 
 val LocalCacheScrollPosition = compositionLocalOf { CacheScrollPosition() }
+val LocalCacheScrollOffsetPosition = compositionLocalOf { CacheScrollOffsetPosition() }