update libs and refactor mvi

.github/workflows/build_mac_os.yml

@@ -33,5 +33,8 @@ jobs:
           LOCAL_PROPERTIES: ${{ secrets.LOCAL_PROPERTIES }}
         run: echo "$LOCAL_PROPERTIES" > ./local.properties
 
+      - name: generate Ksp metadata
+        run: ./gradlew kspKotlinMetadata
+
       - name: Build with Gradle
         run: cd iosApp && xcodebuild -workspace ./iosApp.xcworkspace -scheme iosApp -configuration Debug -destination 'platform=iOS Simulator,OS=latest,name=iPhone 15' CODE_SIGNING_ALLOWED='NO'

build-logic/convention/build.gradle.kts

@@ -8,31 +8,36 @@ dependencies {
     compileOnly(libs.android.gradlePlugin) //if targetting Android
     compileOnly(libs.kotlin.gradlePlugin)
     compileOnly(libs.compose.gradlePlugin) //if you are using Compose Multiplatform
-    compileOnly(libs.ksp.gradlePlugin)
+    implementation(libs.ksp.gradlePlugin)
     compileOnly(libs.room.gradlePlugin) //if you are using Room
 }
 
+tasks {
+    validatePlugins {
+        enableStricterValidation = true
+        failOnWarning = true
+    }
+}
+
 gradlePlugin {
     plugins {
-        register("kotlinLibraryMultiplatform") {
-            id = "convention.kmp.library"
-            implementationClass = "KMPLibraryConventionPlugin"
-        }
-        register("kotlinApplicationMultiplatform") {
-            id = "convention.kmp.application"
-            implementationClass = "KMPApplicationConventionPlugin"
-        }
-        register("kotlinLibraryComposeMultiplatform") {
-            id = "convention.kmp.library.compose"
-            implementationClass = "KMPLibraryComposeConventionPlugin"
-        }
-        register("kotlinLibraryComposeAndroid") {
-            id = "convention.android.library.compose"
-            implementationClass = "KotlinLibraryComposePlugin"
-        }
-        register("kotlinLibraryRoom") {
-            id = "convention.kmp.library.room"
-            implementationClass = "RoomLibraryConventionPlugin"
-        }
+        setup("KMPApplicationConventionPlugin", libs.plugins.convention.kmp.application)
+        setup("KMPLibraryConventionPlugin", libs.plugins.convention.kmp.library.asProvider())
+        setup("KMPLibraryComposeConventionPlugin", libs.plugins.convention.kmp.library.compose)
+        setup("KotlinLibraryComposePlugin", libs.plugins.convention.android.library.compose)
+        setup("RoomLibraryConventionPlugin", libs.plugins.convention.kmp.room)
+        setup("KMPComposeNavigationPlugin", libs.plugins.convention.kmp.navigation)
+        setup("KmpConventionFeature", libs.plugins.convention.kmp.feature)
+    }
+}
+
+fun NamedDomainObjectContainer<PluginDeclaration>.setup(
+    className: String,
+    provider: Provider<PluginDependency>,
+) {
+    val plugin = provider.get()
+    register(plugin.pluginId) {
+        id = plugin.pluginId
+        implementationClass = className
     }
 }

build-logic/convention/src/main/kotlin/KMPApplicationConventionPlugin.kt

@@ -4,19 +4,16 @@ import AppExt.findVersionInt
 import AppExt.findVersionString
 import AppExt.libs
 import com.android.build.api.dsl.ApplicationExtension
-import com.android.build.api.dsl.CommonExtension
-import com.google.devtools.ksp.gradle.KspExtension
 import com.stslex.atten.convention.configureKMPCompose
+import com.stslex.atten.convention.configureKMPComposeNavigation
 import com.stslex.atten.convention.configureKotlin
 import com.stslex.atten.convention.configureKotlinAndroid
 import com.stslex.atten.convention.configureKotlinAndroidCompose
 import com.stslex.atten.convention.configureKotlinMultiplatform
+import com.stslex.atten.convention.configureKsp
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.getByType
-import org.jetbrains.compose.ComposeExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 class KMPApplicationConventionPlugin : Plugin<Project> {
 
@@ -27,25 +24,17 @@ class KMPApplicationConventionPlugin : Plugin<Project> {
             apply(libs.findPluginId("androidApplication"))
             apply(libs.findPluginId("jetbrainsCompose"))
             apply(libs.findPluginId("composeCompiler"))
-            apply(libs.findPluginId("ksp"))
             apply(libs.findPluginId("serialization"))
         }
 
-        extensions.configure<KotlinMultiplatformExtension> {
-            val kspExtension = extensions.getByType<KspExtension>()
-            configureKotlinMultiplatform(this, kspExtension)
-            configureKMPCompose(
-                extension = this,
-                compose = extensions.getByType<ComposeExtension>().dependencies
-            )
-        }
+        configureKsp()
+        configureKotlinMultiplatform()
+        configureKMPCompose()
+        configureKotlin()
+        configureKMPComposeNavigation()
 
         extensions.configure<ApplicationExtension> {
-            configureKotlin()
-            configureKotlinAndroid(
-                extension = this,
-                isApp = true
-            )
+            configureKotlinAndroid(this)
             configureKotlinAndroidCompose(this)
             defaultConfig.apply {
                 applicationId = APP_PREFIX

build-logic/convention/src/main/kotlin/KMPComposeNavigationPlugin.kt

@@ -0,0 +1,10 @@
+import com.stslex.atten.convention.configureKMPComposeNavigation
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class KMPComposeNavigationPlugin : Plugin<Project> {
+
+    override fun apply(target: Project) {
+        target.configureKMPComposeNavigation()
+    }
+}

build-logic/convention/src/main/kotlin/KMPLibraryComposeConventionPlugin.kt

@@ -1,44 +1,10 @@
-import AppExt.findPluginId
-import AppExt.libs
-import com.android.build.api.dsl.LibraryExtension
-import com.stslex.atten.convention.configureKMPCompose
-import com.stslex.atten.convention.configureKotlin
-import com.stslex.atten.convention.configureKotlinAndroid
-import com.stslex.atten.convention.configureKotlinMultiplatform
+import com.stslex.atten.convention.configureKMPComposeLibrary
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.getByType
-import org.jetbrains.compose.ComposeExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 class KMPLibraryComposeConventionPlugin : Plugin<Project> {
 
     override fun apply(target: Project): Unit = with(target) {
-        with(pluginManager) {
-            apply(libs.findPluginId("kotlinMultiplatform"))
-            apply(libs.findPluginId("jetbrainsCompose"))
-            apply(libs.findPluginId("composeCompiler"))
-            apply(libs.findPluginId("kotlinCocoapods"))
-            apply(libs.findPluginId("androidLibrary"))
-            apply(libs.findPluginId("ksp"))
-            apply(libs.findPluginId("serialization"))
-        }
-
-        extensions.configure<KotlinMultiplatformExtension> {
-            configureKMPCompose(
-                extension = this,
-                compose = extensions.getByType<ComposeExtension>().dependencies
-            )
-            configureKotlinMultiplatform(
-                extension = this,
-                kspExtension = extensions.getByType()
-            )
-        }
-
-        extensions.configure<LibraryExtension> {
-            configureKotlin()
-            configureKotlinAndroid(this)
-        }
+        configureKMPComposeLibrary()
     }
 }

build-logic/convention/src/main/kotlin/KMPLibraryConventionPlugin.kt

@@ -1,35 +1,10 @@
-import AppExt.findPluginId
-import AppExt.libs
-import com.android.build.api.dsl.LibraryExtension
-import com.stslex.atten.convention.configureKotlin
-import com.stslex.atten.convention.configureKotlinAndroid
-import com.stslex.atten.convention.configureKotlinMultiplatform
+import com.stslex.atten.convention.configureKmpLibrary
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.getByType
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 class KMPLibraryConventionPlugin : Plugin<Project> {
 
     override fun apply(target: Project): Unit = with(target) {
-        with(pluginManager) {
-            apply(libs.findPluginId("kotlinMultiplatform"))
-            apply(libs.findPluginId("kotlinCocoapods"))
-            apply(libs.findPluginId("androidLibrary"))
-            apply(libs.findPluginId("ksp"))
-            apply(libs.findPluginId("serialization"))
-        }
-
-        extensions.configure<KotlinMultiplatformExtension> {
-            configureKotlinMultiplatform(
-                extension = this,
-                kspExtension = extensions.getByType()
-            )
-        }
-        extensions.configure<LibraryExtension> {
-            configureKotlinAndroid(this)
-            configureKotlin()
-        }
+        configureKmpLibrary()
     }
 }

build-logic/convention/src/main/kotlin/KmpConventionFeature.kt

@@ -0,0 +1,12 @@
+import com.stslex.atten.convention.configureKMPComposeLibrary
+import com.stslex.atten.convention.configureKMPComposeNavigation
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class KmpConventionFeature : Plugin<Project> {
+
+    override fun apply(target: Project) = target.run {
+        configureKMPComposeLibrary()
+        configureKMPComposeNavigation()
+    }
+}

build-logic/convention/src/main/kotlin/KotlinLibraryComposePlugin.kt

@@ -3,6 +3,7 @@ import AppExt.libs
 import com.android.build.api.dsl.LibraryExtension
 import com.stslex.atten.convention.configureKotlin
 import com.stslex.atten.convention.configureKotlinAndroidCompose
+import com.stslex.atten.convention.configureKsp
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -13,10 +14,10 @@ class KotlinLibraryComposePlugin : Plugin<Project> {
         with(pluginManager) {
             apply(libs.findPluginId("androidLibrary"))
             apply(libs.findPluginId("composeCompiler"))
-            apply(libs.findPluginId("ksp"))
         }
+        configureKsp()
+        configureKotlin()
         extensions.configure<LibraryExtension> {
-            configureKotlin()
             configureKotlinAndroidCompose(this)
         }
     }

build-logic/convention/src/main/kotlin/RoomLibraryConventionPlugin.kt

@@ -1,7 +1,8 @@
 import AppExt.findPluginId
 import AppExt.libs
 import androidx.room.gradle.RoomExtension
-import com.google.devtools.ksp.gradle.KspExtension
+import com.stslex.atten.convention.configs.KspConfig
+import com.stslex.atten.convention.configureKsp
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -14,12 +15,11 @@ class RoomLibraryConventionPlugin : Plugin<Project> {
         with(target) {
             pluginManager.apply {
                 apply(libs.findPluginId("room"))
-                apply(libs.findPluginId("ksp"))
                 apply(libs.findPluginId("kotlinMultiplatform"))
                 apply(libs.findPluginId("serialization"))
             }
 
-            extensions.configure<KspExtension> {
+            configureKsp {
                 arg("room.generateKotlin", "true")
             }
 
@@ -30,14 +30,12 @@ class RoomLibraryConventionPlugin : Plugin<Project> {
                 schemaDirectory("$projectDir/schemas")
             }
 
+            dependencies {
+                val roomCompiler = libs.findLibrary("room-compiler").get()
+                KspConfig.platform.forEach { task -> add(task.configName, roomCompiler) }
+            }
+
             extensions.configure<KotlinMultiplatformExtension> {
-                dependencies {
-                    val roomCompiler = libs.findLibrary("room-compiler").get()
-                    add("kspAndroid", roomCompiler)
-                    add("kspIosSimulatorArm64", roomCompiler)
-                    add("kspIosX64", roomCompiler)
-                    add("kspIosArm64", roomCompiler)
-                }
                 sourceSets.apply {
                     commonMain.dependencies {
                         implementation(libs.findLibrary("room-runtime").get())

build-logic/convention/src/main/kotlin/com/stslex/atten/convention/KmpCompose.kt

@@ -2,24 +2,26 @@ package com.stslex.atten.convention
 
 import AppExt.libs
 import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
 import org.jetbrains.compose.ComposePlugin
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
-fun Project.configureKMPCompose(
-    extension: KotlinMultiplatformExtension,
-    compose: ComposePlugin.Dependencies
-) = extension.apply {
+fun Project.configureKMPCompose() = extensions.configure<KotlinMultiplatformExtension> {
+    val dependencies = extensions.getByType<ComposePlugin.Dependencies>()
     sourceSets.apply {
         commonMain.dependencies {
-            // todo need to add compose dependencies
-            implementation(compose.ui)
-            implementation(compose.material3)
-            implementation(compose.foundation)
-            implementation(compose.components.uiToolingPreview)
-            implementation(compose.components.resources)
-            implementation(compose.runtime)
+            implementation(dependencies.ui)
+            implementation(dependencies.material3)
+            implementation(dependencies.foundation)
+            implementation(dependencies.components.uiToolingPreview)
+            implementation(dependencies.components.resources)
+            implementation(dependencies.runtime)
+            implementation(dependencies.materialIconsExtended)
+
             implementation(libs.findLibrary("kotlinx-collections-immutable").get())
             implementation(libs.findLibrary("koin-compose").get())
+            implementation(libs.findLibrary("koin-compose-viewmodel").get())
             implementation(libs.findLibrary("lifecycle-viewmodel").get())
         }
     }

build-logic/convention/src/main/kotlin/com/stslex/atten/convention/KmpComposeNavigation.kt

@@ -0,0 +1,31 @@
+package com.stslex.atten.convention
+
+import AppExt.libs
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.kotlin.dsl.configure
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.cocoapods.CocoapodsExtension
+
+fun Project.configureKMPComposeNavigation() = extensions.configure<KotlinMultiplatformExtension> {
+    sourceSets.apply {
+        commonMain.dependencies {
+            api(libs.findLibrary("decompose").get())
+            api(libs.findLibrary("decompose.extensions").get())
+            api(libs.findLibrary("essenty.lifecycle").get())
+            api(libs.findLibrary("essenty.stateKeeper").get())
+            api(libs.findLibrary("essenty.backHandler").get())
+        }
+        iosMain.dependencies {
+            api(libs.findLibrary("parcelize.darwin").get())
+        }
+    }
+    (this as ExtensionAware).extensions.configure<CocoapodsExtension> {
+        framework {
+            export(libs.findLibrary("decompose").get())
+            export(libs.findLibrary("essenty.lifecycle").get())
+            export(libs.findLibrary("essenty.stateKeeper").get())
+            export(libs.findLibrary("parcelize.darwin").get())
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/stslex/atten/convention/KmpConfigureComposeLibrary.kt

@@ -0,0 +1,14 @@
+package com.stslex.atten.convention
+
+import AppExt.findPluginId
+import AppExt.libs
+import org.gradle.api.Project
+
+fun Project.configureKMPComposeLibrary() {
+    configureKmpLibrary()
+    with(pluginManager) {
+        apply(libs.findPluginId("jetbrainsCompose"))
+        apply(libs.findPluginId("composeCompiler"))
+    }
+    configureKMPCompose()
+}