add compose submodule and add several functions in top of composition

0.9.10

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.9.11
+
+* `Versions`:
+    * `Klock`: `2.6.1` -> `2.6.2`
+* `Coroutines`:
+    * `Compose`:
+        * Created :)
+        * New extensions and function:
+            * `Composition#linkWithJob`
+            * `Composition#linkWithContext`
+            * `renderComposableAndLinkToContext`
+
+## 0.9.10
+
+* `Versions`:
+    * `Klock`: `2.5.2` -> `2.6.1`
+* Ktor:
+    * Client:
+        * New function `UnifiedRequester#createStandardWebsocketFlow` without `checkReconnection` arg
+    * Server:
+        * Now it is possible to filter data in `Route#includeWebsocketHandling`
+        * Callback in `Route#includeWebsocketHandling` and dependent methods is `suspend` since now
+        * Add `URLProtocol` support in `Route#includeWebsocketHandling` and dependent methods
+
 ## 0.9.9
 
 * `Versions`:

android/alerts/common/build.gradle

@@ -10,7 +10,7 @@ kotlin {
     sourceSets {
         androidMain {
             dependencies {
-                api "androidx.appcompat:appcompat-resources:$appcompat_version"
+                api libs.android.appCompat.resources
             }
         }
     }

android/recyclerview/build.gradle

@@ -10,13 +10,13 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
                 api project(":micro_utils.common")
             }
         }
         androidMain {
             dependencies {
-                api "androidx.recyclerview:recyclerview:$androidx_recycler_version"
+                api libs.android.recyclerView
             }
         }
     }

build.gradle

@@ -7,12 +7,12 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.4'
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
-        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
+        classpath libs.buildscript.kt.gradle
+        classpath libs.buildscript.kt.serialization
+        classpath libs.buildscript.jb.dokka
+        classpath libs.buildscript.gh.release
+        classpath libs.buildscript.android.gradle
+        classpath libs.buildscript.android.dexcount
     }
 }
 

coroutines/build.gradle

@@ -10,12 +10,12 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
             }
         }
         androidMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version"
+                api libs.kt.coroutines.android
             }
         }
     }

coroutines/compose/build.gradle

@@ -0,0 +1,18 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    alias(libs.plugins.jb.compose)
+}
+
+apply from: "$mppProjectWithSerializationAndComposePresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api libs.kt.coroutines
+            }
+        }
+    }
+}

coroutines/compose/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/compose/LinkCompositionToJob.kt

@@ -0,0 +1,14 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.job
+import kotlin.coroutines.CoroutineContext
+
+fun Composition.linkWithJob(job: Job) {
+    job.invokeOnCompletion {
+        this@linkWithJob.dispose()
+    }
+}
+
+fun Composition.linkWithContext(coroutineContext: CoroutineContext) = linkWithJob(coroutineContext.job)

coroutines/compose/src/jsMain/kotlin/dev/inmo/micro_utils/coroutines/compose/RenderComposableWithLinkToContext.kt

@@ -0,0 +1,16 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.*
+import kotlinx.coroutines.*
+import org.jetbrains.compose.web.dom.DOMScope
+import org.w3c.dom.Element
+
+suspend fun <TElement : Element> renderComposableAndLinkToContext(
+    root: TElement,
+    monotonicFrameClock: MonotonicFrameClock = DefaultMonotonicFrameClock,
+    content: @Composable DOMScope<TElement>.() -> Unit
+): Composition = org.jetbrains.compose.web.renderComposable(root, monotonicFrameClock, content).apply {
+    linkWithContext(
+        currentCoroutineContext()
+    )
+}

coroutines/compose/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.coroutines.compose"/>

defaultAndroidSettings.gradle

@@ -26,12 +26,12 @@ ext {
 }
 
 android {
-    compileSdkVersion "$android_compileSdkVersion".toInteger()
-    buildToolsVersion "$android_buildToolsVersion"
+    compileSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
+    buildToolsVersion libs.versions.android.props.buildTools.get()
 
     defaultConfig {
-        minSdkVersion "$android_minSdkVersion".toInteger()
-        targetSdkVersion "$android_compileSdkVersion".toInteger()
+        minSdkVersion libs.versions.android.props.minSdk.get().toInteger()
+        targetSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
         versionCode "${android_code_version}".toInteger()
         versionName "$version"
     }

extensions.gradle

@@ -21,6 +21,7 @@ allprojects {
         releaseMode = (project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true"
 
         mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
+        mppProjectWithSerializationAndComposePresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerializationAndCompose.gradle"
         mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 

gradle.properties

@@ -7,43 +7,12 @@ android.useAndroidX=true
 android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2g
 
-kotlin_version=1.6.10
-kotlin_coroutines_version=1.6.0
-kotlin_serialisation_core_version=1.3.2
-kotlin_exposed_version=0.37.3
-
-ktor_version=1.6.7
-
-klockVersion=2.5.2
-
-github_release_plugin_version=2.2.12
-
-uuidVersion=0.4.0
-
-# ANDROID
-
-core_ktx_version=1.7.0
-androidx_recycler_version=1.2.1
-appcompat_version=1.4.1
-
-android_minSdkVersion=19
-android_compileSdkVersion=32
-android_buildToolsVersion=32.0.0
-dexcount_version=3.0.1
-junit_version=4.12
-test_ext_junit_version=1.1.2
-espresso_core=3.3.0
-
 # JS NPM
 
 crypto_js_version=4.1.1
 
-# Dokka
-
-dokka_version=1.6.10
-
 # Project data
 
 group=dev.inmo
-version=0.9.9
-android_code_version=99
+version=0.9.11
+android_code_version=101

gradle/libs.versions.toml

@@ -0,0 +1,77 @@
+[versions]
+
+kt = "1.6.10"
+kt-serialization = "1.3.2"
+kt-coroutines = "1.6.0"
+
+jb-compose = "1.1.0"
+jb-exposed = "0.37.3"
+jb-dokka = "1.6.10"
+
+klock = "2.6.2"
+uuid = "0.4.0"
+
+ktor = "1.6.7"
+
+gh-release = "2.2.12"
+
+android-gradle = "7.0.4"
+dexcount = "3.0.1"
+
+android-coreKtx = "1.7.0"
+android-recyclerView = "1.2.1"
+android-appCompat = "1.4.1"
+android-espresso = "3.3.0"
+android-test = "1.1.2"
+
+android-props-minSdk = "19"
+android-props-compileSdk = "32"
+android-props-buildTools = "32.0.0"
+
+[libraries]
+
+kt-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kt" }
+
+kt-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kt-serialization" }
+kt-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-cbor", version.ref = "kt-serialization" }
+
+kt-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kt-coroutines" }
+kt-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kt-coroutines" }
+
+
+ktor-client = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-java = { module = "io.ktor:ktor-client-java", version.ref = "ktor" }
+ktor-server = { module = "io.ktor:ktor-server", version.ref = "ktor" }
+ktor-server-cio = { module = "io.ktor:ktor-server-cio", version.ref = "ktor" }
+ktor-server-host-common = { module = "io.ktor:ktor-server-host-common", version.ref = "ktor" }
+ktor-websockets = { module = "io.ktor:ktor-websockets", version.ref = "ktor" }
+
+
+klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "klock" }
+uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
+
+
+jb-exposed = { module = "org.jetbrains.exposed:exposed-core", version.ref = "jb-exposed" }
+
+
+android-coreKtx = { module = "androidx.core:core-ktx", version.ref = "android-coreKtx" }
+android-recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "android-recyclerView" }
+android-appCompat-resources = { module = "androidx.appcompat:appcompat-resources", version.ref = "android-appCompat" }
+android-espresso = { module = "androidx.test.espresso:espresso-core", version.ref = "android-espresso" }
+android-test-junit = { module = "androidx.test.ext:junit", version.ref = "android-test" }
+
+
+kt-test-js = { module = "org.jetbrains.kotlin:kotlin-test-js", version.ref = "kt" }
+kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kt" }
+
+
+buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
+buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
+buildscript-jb-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "jb-dokka" }
+buildscript-gh-release = { module = "com.github.breadmoirai:github-release", version.ref = "gh-release" }
+buildscript-android-gradle = { module = "com.android.tools.build:gradle", version.ref = "android-gradle" }
+buildscript-android-dexcount = { module = "com.getkeepsafe.dexcount:dexcount-gradle-plugin", version.ref = "dexcount" }
+
+[plugins]
+
+jb-compose = { id = "org.jetbrains.compose", version.ref = "jb-compose" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

ktor/client/build.gradle

@@ -12,7 +12,7 @@ kotlin {
             dependencies {
                 api internalProject("micro_utils.ktor.common")
                 api internalProject("micro_utils.coroutines")
-                api "io.ktor:ktor-client-core:$ktor_version"
+                api libs.ktor.client
             }
         }
     }

ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/client/FlowsWebsockets.kt

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
 import io.ktor.client.features.websocket.ws
+import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.http.cio.websocket.Frame
 import io.ktor.http.cio.websocket.readBytes
 import kotlinx.coroutines.flow.Flow
@@ -17,6 +18,7 @@ import kotlinx.serialization.DeserializationStrategy
 inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
     crossinline checkReconnection: (Throwable?) -> Boolean = { true },
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {},
     crossinline conversation: suspend (StandardKtorSerialInputData) -> T
 ): Flow<T> {
     val correctedUrl = url.asCorrectWebSocketUrl
@@ -26,7 +28,7 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
         do {
             val reconnect = try {
                 safely {
-                    ws(correctedUrl) {
+                    ws(correctedUrl, requestBuilder) {
                         for (received in incoming) {
                             when (received) {
                                 is Frame.Binary -> producerScope.send(conversation(received.readBytes()))
@@ -65,10 +67,12 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
     crossinline checkReconnection: (Throwable?) -> Boolean = { true },
     deserializer: DeserializationStrategy<T>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    noinline requestBuilder: HttpRequestBuilder.() -> Unit = {},
 ) = createStandardWebsocketFlow(
     url,
-    checkReconnection
+    checkReconnection,
+    requestBuilder
 ) {
     serialFormat.decodeDefault(deserializer, it)
 }

ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/client/StandardHttpClientGetPost.kt

@@ -85,9 +85,16 @@ class UnifiedRequester(
 
     fun <T> createStandardWebsocketFlow(
         url: String,
-        checkReconnection: (Throwable?) -> Boolean = { true },
-        deserializer: DeserializationStrategy<T>
-    ) = client.createStandardWebsocketFlow(url, checkReconnection, deserializer, serialFormat)
+        checkReconnection: (Throwable?) -> Boolean,
+        deserializer: DeserializationStrategy<T>,
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ) = client.createStandardWebsocketFlow(url, checkReconnection, deserializer, serialFormat, requestBuilder)
+
+    fun <T> createStandardWebsocketFlow(
+        url: String,
+        deserializer: DeserializationStrategy<T>,
+        requestBuilder: HttpRequestBuilder.() -> Unit = {},
+    ) = createStandardWebsocketFlow(url, { true  }, deserializer, requestBuilder)
 }
 
 val defaultRequester = UnifiedRequester()

ktor/common/build.gradle

@@ -11,8 +11,8 @@ kotlin {
         commonMain {
             dependencies {
                 api internalProject("micro_utils.common")
-                api "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$kotlin_serialisation_core_version"
-                api "com.soywiz.korlibs.klock:klock:$klockVersion"
+                api libs.kt.serialization.cbor
+                api libs.klock
             }
         }
     }

ktor/server/build.gradle

@@ -16,10 +16,10 @@ kotlin {
 
         jvmMain {
             dependencies {
-                api "io.ktor:ktor-server:$ktor_version"
-                api "io.ktor:ktor-server-cio:$ktor_version"
-                api "io.ktor:ktor-server-host-common:$ktor_version"
-                api "io.ktor:ktor-websockets:$ktor_version"
+                api libs.ktor.server
+                api libs.ktor.server.cio
+                api libs.ktor.server.host.common
+                api libs.ktor.websockets
             }
         }
     }

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/FlowsWebsocket.kt

@@ -4,25 +4,29 @@ import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.application.featureOrNull
 import io.ktor.application.install
+import io.ktor.http.URLProtocol
 import io.ktor.http.cio.websocket.*
 import io.ktor.routing.Route
 import io.ktor.routing.application
-import io.ktor.websocket.webSocket
+import io.ktor.websocket.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.SerializationStrategy
 
 fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
-    converter: (T) -> StandardKtorSerialInputData
+    protocol: URLProtocol = URLProtocol.WS,
+    converter: suspend WebSocketServerSession.(T) -> StandardKtorSerialInputData?
 ) {
     application.apply {
         featureOrNull(io.ktor.websocket.WebSockets) ?: install(io.ktor.websocket.WebSockets)
     }
-    webSocket(suburl) {
+    webSocket(suburl, protocol.name) {
         safely {
             flow.collect {
-                send(converter(it))
+                converter(it) ?.let { data ->
+                    send(data)
+                }
             }
         }
     }
@@ -32,10 +36,24 @@ fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
     serializer: SerializationStrategy<T>,
-    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    protocol: URLProtocol = URLProtocol.WS,
+    filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
 ) = includeWebsocketHandling(
     suburl,
-    flow
-) {
+    flow,
+    protocol,
+    converter = if (filter == null) {
+        {
             serialFormat.encodeDefault(serializer, it)
-}
+        }
+    } else {
+        {
+            if (filter(it)) {
+                serialFormat.encodeDefault(serializer, it)
+            } else {
+                null
+            }
+        }
+    }
+)

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/ServerRoutingShortcuts.kt

@@ -5,8 +5,7 @@ import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.application.ApplicationCall
 import io.ktor.application.call
-import io.ktor.http.ContentType
-import io.ktor.http.HttpStatusCode
+import io.ktor.http.*
 import io.ktor.http.content.PartData
 import io.ktor.http.content.forEachPart
 import io.ktor.request.receive
@@ -18,6 +17,7 @@ import io.ktor.util.asStream
 import io.ktor.util.cio.writeChannel
 import io.ktor.util.pipeline.PipelineContext
 import io.ktor.utils.io.core.*
+import io.ktor.websocket.WebSocketServerSession
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.*
 import java.io.File
@@ -30,8 +30,10 @@ class UnifiedRouter(
     fun <T> Route.includeWebsocketHandling(
         suburl: String,
         flow: Flow<T>,
-        serializer: SerializationStrategy<T>
-    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat)
+        serializer: SerializationStrategy<T>,
+        protocol: URLProtocol = URLProtocol.WS,
+        filter: (suspend WebSocketServerSession.(T) -> Boolean)? = null
+    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat, protocol, filter)
 
     suspend fun <T> PipelineContext<*, ApplicationCall>.unianswer(
         answerSerializer: SerializationStrategy<T>,

language_codes/generator/build.gradle

@@ -4,8 +4,8 @@ buildscript {
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath libs.buildscript.kt.gradle
+        classpath libs.buildscript.kt.serialization
     }
 }
 
@@ -16,11 +16,11 @@ plugins {
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_core_version"
+    implementation libs.kt.stdlib
+    implementation libs.kt.serialization
 
-    implementation "io.ktor:ktor-client-core:$ktor_version"
-    implementation "io.ktor:ktor-client-java:$ktor_version"
+    implementation libs.ktor.client
+    implementation libs.ktor.client.java
 }
 
 mainClassName="MainKt"

mppProjectWithSerialization.gradle

@@ -23,7 +23,7 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
-                api "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialisation_core_version"
+                implementation libs.kt.serialization
             }
         }
         commonTest {
@@ -46,8 +46,8 @@ kotlin {
         androidTest {
             dependencies {
                 implementation kotlin('test-junit')
-                implementation "androidx.test.ext:junit:$test_ext_junit_version"
-                implementation "androidx.test.espresso:espresso-core:$espresso_core"
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
             }
         }
     }

mppProjectWithSerializationAndCompose.gradle

@@ -0,0 +1,72 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publishGradlePath"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+    }
+    js (IR) {
+        browser()
+        nodejs()
+    }
+    android {
+        publishAllLibraryVariants()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                implementation libs.kt.serialization
+                implementation compose.runtime
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+            }
+        }
+        jvmMain {
+            dependencies {
+                implementation compose.desktop.currentOs
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsMain {
+            dependencies {
+                implementation compose.web.core
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+                implementation kotlin('test-junit')
+            }
+        }
+        androidTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+            }
+        }
+    }
+}
+
+apply from: "$defaultAndroidSettingsPresetPath"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

pagination/exposed/build.gradle

@@ -14,7 +14,7 @@ kotlin {
         }
         jvmMain {
             dependencies {
-                api "org.jetbrains.exposed:exposed-core:$kotlin_exposed_version"
+                api libs.jb.exposed
             }
         }
     }

pagination/ktor/server/build.gradle

@@ -15,8 +15,8 @@ kotlin {
 
         jvmMain {
             dependencies {
-                api "io.ktor:ktor-server:$ktor_version"
-                api "io.ktor:ktor-server-host-common:$ktor_version"
+                api libs.ktor.server
+                api libs.ktor.server.host.common
             }
         }
     }

repos/common/build.gradle

@@ -10,10 +10,10 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
                 api internalProject("micro_utils.pagination.common")
 
-                api "com.benasher44:uuid:$uuidVersion"
+                api libs.uuid
             }
         }
 
@@ -24,7 +24,7 @@ kotlin {
         }
         androidMain {
             dependencies {
-                api "androidx.core:core-ktx:$core_ktx_version"
+                api libs.android.coreKtx
                 api internalProject("micro_utils.common")
                 api internalProject("micro_utils.coroutines")
             }

selector/common/build.gradle

@@ -10,7 +10,7 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+                api libs.kt.coroutines
             }
         }
     }

settings.gradle

@@ -23,6 +23,7 @@ String[] includes = [
     ":ktor:common",
     ":ktor:client",
     ":coroutines",
+    ":coroutines:compose",
     ":android:recyclerview",
     ":android:alerts:common",
     ":android:alerts:recyclerview",
@@ -38,11 +39,13 @@ String[] includes = [
 
 
 includes.each { originalName ->
-    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replaceAll(":", File.separator)}"
-    String projectName = "${rootProject.name}${originalName.replaceAll(":", ".")}"
+    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replace(":", File.separator)}"
+    String projectName = "${rootProject.name}${originalName.replace(":", ".")}"
     String projectIdentifier = ":${projectName}"
     include projectIdentifier
     ProjectDescriptor project = project(projectIdentifier)
     project.name = projectName
     project.projectDir = new File(projectDirectory)
 }
+
+enableFeaturePreview("VERSION_CATALOGS")