Refactored experimental OnInit API

Author: wkornewald

.gitattributes

@@ -0,0 +1 @@
+*.bat text eol=crlf

CHANGELOG.md

@@ -5,6 +5,7 @@
 * Added reactive dependency injection solution (see `DI`) with graph tracking that can even re-create ViewModels when a DI module/node is changed at runtime.
 * Added `ContextualVal`/`ContextualValSuspend` for coroutine-local variables (like thread-locals or `CompositionLocal` for coroutines).
 * Made the experimental `ReactiveViewModel` more flexible by building it around `ContextualVal`.
+* Added experimental `OnInit` API for initial loading of ViewModel data with error and retry handling.
 * Added Composable `rememberOnViewModel { ... }` which remembers the block's result across configuration changes.
 * Added Composable `DI.derivedState { ... }` and `DI.derivedValue { ... }` which remember the block's result until a dependency changes and re-render the UI when needed.
 * Changed `loading` and all `withLoading` parameters from `MutableValueFlow` to `MutableStateFlow`.

build-logic/build-logic-base/src/main/kotlin/com/ensody/buildlogic/KotlinMultiplatformExt.kt

@@ -75,20 +75,26 @@ fun KotlinMultiplatformExtension.applyKmpHierarchy(block: KotlinHierarchyBuilder
             }
             group("appleMobile") {
                 withIos()
+                group("ios")
                 withTvos()
                 withWatchos()
             }
             group("compose") {
+                group("js")
                 withJs()
+                group("wasmJs")
                 withWasmJs()
                 withWasmWasi()
+                group("ios")
                 withIos()
                 withJvm()
                 withAndroidTarget()
             }
             group("nonJvm") {
                 withNative()
+                group("js")
                 withJs()
+                group("wasmJs")
                 withWasmJs()
             }
             group("nonJs") {

gradle/libs.versions.toml

@@ -40,7 +40,7 @@ ktlint-cli = { module = "com.pinterest.ktlint:ktlint-cli", version = "1.6.0" }
 mockk = { module = "io.mockk:mockk", version = "1.14.4" }
 robolectric = { module = "org.robolectric:robolectric", version = "4.15.1" }
 
-gradle-android = { module = "com.android.tools.build:gradle", version = "8.10.0" }
+gradle-android = { module = "com.android.tools.build:gradle", version = "8.11.1" }
 gradle-kotlin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 gradle-cocoapods = { module = "org.jetbrains.kotlin.native.cocoapods:org.jetbrains.kotlin.native.cocoapods.gradle.plugin", version.ref = "kotlin" }
 gradle-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version = "2.0.0" }

reactivestate-compose/src/composeMain/kotlin/com/ensody/reactivestate/compose/ViewModelExt.kt

@@ -13,13 +13,12 @@ import androidx.lifecycle.viewmodel.compose.viewModel
 import com.ensody.reactivestate.ContextualErrorsFlow
 import com.ensody.reactivestate.ContextualStateFlowStore
 import com.ensody.reactivestate.ContextualValRoot
-import com.ensody.reactivestate.CoroutineLauncher
 import com.ensody.reactivestate.DI
 import com.ensody.reactivestate.ExperimentalReactiveStateApi
 import com.ensody.reactivestate.InMemoryStateFlowStore
 import com.ensody.reactivestate.ReactiveStateContext
+import com.ensody.reactivestate.ReactiveViewModel
 import com.ensody.reactivestate.invokeOnCompletion
-import com.ensody.reactivestate.triggerOnInit
 import com.ensody.reactivestate.withSpinLock
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.MainScope
@@ -39,14 +38,14 @@ import kotlinx.coroutines.sync.Mutex
  */
 @ExperimentalReactiveStateApi
 @Composable
-public inline fun <reified VM : CoroutineLauncher> reactiveViewModel(
+public inline fun <reified VM : ReactiveViewModel> reactiveViewModel(
     key: String? = null,
     crossinline onError: (Throwable) -> Unit,
     crossinline provider: ReactiveStateContext.() -> VM,
 ): State<VM> =
     onViewModel(key = key) {
         provider().also {
-            it.triggerOnInit()
+            it.onInit.trigger()
         }
     }.also { viewModel ->
         LaunchedEffect(viewModel.value) {

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/ContextualVal.kt

@@ -4,6 +4,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.plus
 import kotlinx.coroutines.withContext
+import kotlin.collections.set
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.coroutineContext
@@ -105,3 +106,32 @@ public fun requireContextualValRoot(scope: CoroutineScope) {
 public fun requireContextualValRoot(context: CoroutineContext) {
     requireNotNull(context[ContextualValRootInternal.key]) { "ContextualValRoot is missing in the CoroutineScope" }
 }
+
+public val ContextualStore: ContextualVal<ContextualValStore> = ContextualVal("ContextualStore") {
+    requireContextualValRoot(it)
+    ContextualValStore()
+}
+
+public class ContextualValStore {
+    public class Key<T>
+
+    private val storage = mutableMapOf<Key<*>, Any?>()
+
+    public operator fun contains(key: Key<*>): Boolean =
+        key in storage
+
+    @Suppress("UNCHECKED_CAST")
+    public operator fun <T> get(key: Key<T>): T? =
+        storage[key] as T?
+
+    @Suppress("UNCHECKED_CAST")
+    public fun <T> getOrPut(
+        key: Key<T>,
+        defaultValue: () -> T,
+    ): T =
+        storage.getOrPut(key, defaultValue) as T
+
+    public fun <T> put(key: Key<T>, value: T) {
+        storage[key] = value
+    }
+}

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/OnInit.kt

@@ -18,11 +18,11 @@ import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.js.JsName
 
 /**
- * A mechanism for ViewModel initialization-time tasks like repository cache refresh. Use via [ContextualOnInit].
+ * A mechanism for [ReactiveViewModel] initialization-time tasks like repository cache refresh.
  *
  * With [observe] you get notified when the ViewModel is ready. On the provided [OnInitContext] you can launch
  * coroutines which are associated with your observer. If any of the coroutines fail the [state] will reflect that
- * and you can run [trigger] (or the simpler [CoroutineLauncher.triggerOnInit]) again for only the failing observers.
+ * and you can run [trigger] again for only the failing observers.
  */
 @ExperimentalReactiveStateApi
 public interface OnInit {
@@ -37,7 +37,7 @@ public interface OnInit {
 
     public fun observe(block: OnInitContext.() -> Unit)
     public fun unobserve(block: OnInitContext.() -> Unit)
-    public fun trigger(source: CoroutineLauncher)
+    public fun trigger()
 
     public sealed interface State {
         public data object Initializing : State
@@ -46,24 +46,6 @@ public interface OnInit {
     }
 }
 
-/**
- * Provides access to a ViewModel's [OnInit] instance.
- */
-@ExperimentalReactiveStateApi
-public val ContextualOnInit: ContextualVal<OnInit> = ContextualVal("ContextualOnInit") {
-    requireContextualValRoot(it)
-    OnInit()
-}
-
-@ExperimentalReactiveStateApi
-public val CoroutineLauncher.onInit: OnInit get() = ContextualOnInit.get(scope)
-
-/** Runs [OnInit.trigger] for this class. */
-@ExperimentalReactiveStateApi
-public fun CoroutineLauncher.triggerOnInit() {
-    ContextualOnInit.get(scope).trigger(this)
-}
-
 /**
  * When the ViewModel is ready this API allows launching coroutines.
  *
@@ -110,32 +92,25 @@ public interface OnInitContext {
 
 @JsName("createOnInit")
 @ExperimentalReactiveStateApi
-public fun OnInit(): OnInit =
-    OnInitImpl()
+public fun OnInit(source: CoroutineLauncher): OnInit =
+    OnInitImpl(source)
 
-private class OnInitImpl : OnInit {
-    private var source: CoroutineLauncher? = null
+private class OnInitImpl(private val source: CoroutineLauncher) : OnInit {
     private val observers: MutableStateFlow<List<OnInitContext.() -> Unit>> = MutableStateFlow(emptyList())
     private val mutex = Mutex()
 
     override val state: MutableStateFlow<OnInit.State> = MutableStateFlow(OnInit.State.Initializing)
 
     override fun observe(block: OnInitContext.() -> Unit) {
         observers.replace { plus(block) }
-        source?.let {
-            trigger(it)
-        }
+        trigger()
     }
 
     override fun unobserve(block: OnInitContext.() -> Unit) {
         observers.replace { minus(block) }
     }
 
-    override fun trigger(source: CoroutineLauncher) {
-        if (this.source == null) {
-            this.source = source
-        }
-
+    override fun trigger() {
         source.launch(withLoading = null) {
             mutex.withLock {
                 if (observers.value.isNotEmpty()) {

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/ReactiveViewModel.kt

@@ -10,11 +10,12 @@ import kotlinx.coroutines.flow.MutableStateFlow
  *
  * The [scope] is meant to be filled with [ContextualVal] entries.
  *
- * For example, the [ContextualOnInit] hook can be used to launch coroutines via a [CoroutineLauncher]
- * directly from the ViewModel constructor, so you can have nicer error handling and loading indicators.
+ * The [onInit] hook can be used to launch coroutines via a [CoroutineLauncher] directly from the ViewModel constructor,
+ * so you can have nicer error handling and loading indicators.
  */
 @ExperimentalReactiveStateApi
-public abstract class ReactiveViewModel(final override val scope: CoroutineScope) : CoroutineLauncher {
+public abstract class ReactiveViewModel(public final override val scope: CoroutineScope) : CoroutineLauncher {
+    public val onInit: OnInit = ContextualStore.get(scope).getOrPut(OnInitKey) { OnInit(this) }
     private val emittedErrors: MutableFlow<Throwable> = ContextualErrorsFlow.get(scope)
     override val loading: MutableStateFlow<Int> = ContextualLoading.get(scope)
     public val stateFlowStore: StateFlowStore by lazy { ContextualStateFlowStore.get(scope) }
@@ -24,6 +25,8 @@ public abstract class ReactiveViewModel(final override val scope: CoroutineScope
     }
 }
 
+private val OnInitKey = ContextualValStore.Key<OnInit>()
+
 @ExperimentalReactiveStateApi
 public val ContextualErrorsFlow: ContextualVal<MutableFlow<Throwable>> = ContextualVal("ContextualErrorsFlow") {
     requireContextualValRoot(it)

reactivestate-core/src/commonTest/kotlin/com/ensody/reactivestate/ReactiveViewModelTest.kt

@@ -16,7 +16,7 @@ internal class ReactiveViewModelTest : CoroutineTest(ContextualValRoot()) {
     fun nestingOfReactiveViewModels() = runTest {
         assertEquals(0, viewModel.loading.value)
         assertEquals(OnInit.State.Initializing, viewModel.onInit.state.value)
-        viewModel.triggerOnInit()
+        viewModel.onInit.trigger()
         runCurrent()
         assertEquals(OnInit.State.Initializing, viewModel.onInit.state.value)
         assertEquals(1, viewModel.loading.value)