update dependencies

.gitignore

@@ -1,5 +1,4 @@
 .idea
-.vscode
 .kotlin
 out/*
 *.iml
@@ -10,7 +9,6 @@ settings.xml
 .gradle/
 build/
 out/
-bin/
 
 secret.gradle
 local.properties

CHANGELOG.md

@@ -1,175 +1,5 @@
 # Changelog
 
-## 0.26.0
-
-**WARNING!!! SINCE THIS VERSION IF YOU WANT TO USE SOME OF KSP MODULES, SET `ksp.useKSP2=false` IN YOUR `gradle.properties`** (see [gh issue 2491](https://github.com/google/ksp/issues/2491))
-
-* `Versions`:
-  * `Kotlin`: `2.1.21` -> `2.2.0`
-  * `Serialization`: `1.8.1` -> `1.9.0`
-  * `KSLog`: `1.4.2` -> `1.5.0`
-  * `Ktor`: `3.1.3` -> `3.2.1`
-  * `Koin`: `4.0.4` -> `4.1.0`
-  * `Okio`: `3.12.0` -> `3.15.0`
-  * `KSP`: `2.1.20-1.0.31` -> `2.2.0-2.0.2`
-  * `kotlin-poet`: `1.18.1` -> `2.2.0`
-
-## 0.25.8
-
-* `Pagination`:
-  * `Compose`:
-    * New function `rememberInfinityPagedComponentContext` to create `InfinityPagedComponentContext`
-    * New variants of `InfinityPagedComponent` component
-
-## 0.25.7
-
-* `Versions`:
-  * `Compose`: `1.8.0` -> `1.8.1`
-  * `Xerial SQLite`: `3.49.1.0` -> `3.50.1.0`
-  * `Okio`: `3.11.0` -> `3.12.0`
-  * `Android AppCompat`: `1.7.0` -> `1.7.1`
-  * `Android Fragment`: `1.8.6` -> `1.8.8`
-
-## 0.25.6
-
-* `Versions`:
-  * `Kotlin`: `2.1.20` -> `2.1.21`
-  * `KSLog`: `1.4.1` -> `1.4.2`
-  * `Compose`: `1.7.3` -> `1.8.0`
-  * `Okio`: `3.10.2` -> `3.11.0`
-
-## 0.25.5
-
-* `Versions`:
-  * `Exposed`: `0.60.0` -> `0.61.0`
-  * `Serialization`: `1.8.0` -> `1.8.1`
-  * `Coroutines`: `1.10.1` -> `1.10.2`
-* `Common`:
-  * Small performance optimization of `MutableMap.applyDiff`
-
-## 0.25.4
-
-* `Versions`:
-  * `Ktor`: `3.1.1` -> `3.1.2`
-  * `Koin`: `4.0.2` -> `4.0.4`
-* `Coroutines`:
-  * Add `SmartKeyRWLocker.withWriteLocks` extension with vararg keys
-* `Transactions`:
-  * Fix order of rollback actions calling
-
-## 0.25.3
-
-* `Coroutines`:
-  * Add extensions `SmartRWLocker.alsoWithUnlockingOnSuccessAsync` and `SmartRWLocker.alsoWithUnlockingOnSuccess`
-  * Fix of `SmartRWLocker.lockWrite` issue when it could lock write mutex without unlocking
-  * Add tool `SmartKeyRWLocker`
-  * `SmartSemaphore` got new property `maxPermits`
-  * New extension `SmartSemaphore.waitReleaseAll()`
-* `Transactions`:
-  * Add `TransactionsDSL`
-
-## 0.25.2
-
-* `Versions`:
-  * `Exposed`: `0.59.0` -> `0.60.0`
-* `Repo`:
-  * `Cache`:
-    * Add extensions `alsoInvalidate`, `alsoInvalidateAsync`, `alsoInvalidateSync` and `alsoInvalidateSyncLogging`
-* `Koin`:
-  * Add extensions `singleSuspend` and `factorySuspend` for defining of dependencies with suspendable blocks
-
-## 0.25.1
-
-* `Coroutines`:
-  * Add `SortedMapLikeBinaryTreeNode`
-* `Pagination`:
-  * `Compose`:
-    * One more rework of `InfinityPagedComponent` and `PagedComponent`
-
-## 0.25.0
-
-* `Repos`:
-  * `Cache`:
-    * All cache repos now do not have `open` vals - to avoid collisions in runtime
-
-## 0.24.9
-
-* `Pagination`:
-  * Make alternative constructor parameter `size` of `PaginationResult` with default value
-  * Add `Pagination.previousPage` extension
-  * `Compose`:
-    * Rework of `InfinityPagedComponentContext`
-    * Rework of `PagedComponent`
-
-## 0.24.8
-
-* `Versions`:
-  * `Ktor`: `3.1.0` -> `3.1.1`
-  * `KSP`: `2.1.10-1.0.30` -> `2.1.10-1.0.31`
-* `Common`:
-  * `Compose`:
-    * Add component `LoadableComponent`
-* `Coroutines`:
-  * Add `SortedBinaryTreeNode`
-* `Pagination`:
-  * `Compose`:
-    * Add components `PagedComponent` and `InfinityPagedComponent`
-
-## 0.24.7
-
-* `Versions`:
-  * `SQLite`: `3.49.0.0` -> `3.49.1.0`
-* `Common`:
-  * Add `retryOnFailure` utility for simple retries code writing
-* `Repos`:
-  * `Cache`:
-    * Fix of `FullKeyValueCacheRepo` fields usage
-  * `Exposed`:
-    * `AbstractExposedKeyValuesRepo` will produce `onValueRemoved` event on `set` if some data has been removed
-
-## 0.24.6
-
-* `Versions`:
-  * `KSLog`: `1.4.0` -> `1.4.1`
-  * `Exposed`: `0.58.0` -> `0.59.0`
-  * `SQLite`: `3.48.0.0` -> `3.49.0.0`
-  * `AndroidFragment`: `1.8.5` -> `1.8.6`
-* `Coroutines`:
-  * Safely functions has been replaced with `Logging` variations (resolve of [#541](https://github.com/InsanusMokrassar/MicroUtils/issues/541))
-* `KSP`:
-  * `Variations`:
-    * Module has been created
-
-## 0.24.5
-
-* `Versions`:
-  * `Kotlin`: `2.1.0` -> `2.1.10`
-  * `SQLite`: `3.47.2.0` -> `3.48.0.0`
-  * `Koin`: `4.0.1` -> `4.0.2`
-  * `Android RecyclerView`: `1.3.2` -> `1.4.0`
-
-## 0.24.4
-
-* `Repos`:
-  * `Exposed`:
-    * Improve `CommonExposedRepo.selectByIds`
-* `FSM`:
-  * Fixes and improvements
-
-## 0.24.3
-
-* `Ksp`:
-  * `Sealed`:
-    * Fixes in processing of `GenerateSealedTypesWorkaround` annotations
-
-## 0.24.2
-
-* `Versions`:
-  * `Exposed`: `0.57.0` -> `0.58.0`
-* `Ksp`:
-  * `Sealed`:
-    * Add annotation `GenerateSealedTypesWorkaround` which allow to generate `subtypes` lists
-
 ## 0.24.1
 
 * `Versions`:

README.md

@@ -35,51 +35,3 @@ Most of complex modules are built with next hierarchy:
     * `common` part contains routes which are common for clients and servers
     * `client` submodule contains clients which are usually using `UnifiedRequester` to make requests using routes from `ktor/common` module and some internal logic of requests
     * `server` submodule (in most cases `JVM`-only) contains some extensions for `Route` instances which usually will give opportunity to proxy internet requests from `ktor/client` realization to some proxy object
-
-## Gradle Templates
-
-All templates can be used by applying them in your project's build.gradle files using the `apply from` directive. For example:
-
-```gradle
-apply from: "$defaultProject"
-```
-
-In the sample has been used `defaultProject.gradle` as a basic template.
-
-The project includes a collection of Gradle templates to simplify project setup and configuration. These templates are located in the `gradle/templates` directory and can be used to quickly set up different types of projects:
-
-### Project Setup Templates
-
-* `defaultProject.gradle` (usage `apply from: "$defaultProject"`) - Basic project configuration
-* `defaultProjectWithSerialization.gradle` (usage `apply from: "$defaultProjectWithSerialization"`) - Project configuration with Kotlin Serialization support
-* `mppJavaProject.gradle` (usage `apply from: "$mppJavaProject"`) - Multiplatform project with Java support
-* `mppAndroidProject.gradle` (usage `apply from: "$mppAndroidProject"`) - Multiplatform project with Android support
-
-### Multiplatform Configuration Templates
-
-* `enableMPPAndroid.gradle` (usage `apply from: "$enableMPPAndroid"`) - Enable Android target in multiplatform project
-* `enableMPPJs.gradle` (usage `apply from: "$enableMPPJs"`) - Enable JavaScript target in multiplatform project
-* `enableMPPJvm.gradle` (usage `apply from: "$enableMPPJvm"`) - Enable JVM target in multiplatform project
-* `enableMPPNativeArm64.gradle` (usage `apply from: "$enableMPPNativeArm64"`) - Enable ARM64 native target
-* `enableMPPNativeX64.gradle` (usage `apply from: "$enableMPPNativeX64"`) - Enable x64 native target
-* `enableMPPWasmJs.gradle` (usage `apply from: "$enableMPPWasmJs"`) - Enable WebAssembly JavaScript target
-
-### Compose Integration Templates
-
-* `addCompose.gradle` (usage `apply from: "$addCompose"`) - Basic Compose configuration
-* `addComposeForAndroid.gradle` (usage `apply from: "$addComposeForAndroid"`) - Compose configuration for Android
-* `addComposeForDesktop.gradle` (usage `apply from: "$addComposeForDesktop"`) - Compose configuration for Desktop
-* `addComposeForJs.gradle` (usage `apply from: "$addComposeForJs"`) - Compose configuration for JavaScript
-
-### Publishing Templates
-
-* `publish.gradle` (usage `apply from: "$publish"`) - General publishing configuration
-* `publish_jvm.gradle` (usage `apply from: "$publish_jvm"`) - JVM-specific publishing configuration
-* `publish.kpsb` and `publish_jvm.kpsb` (usage `apply from: "$publish_kpsb"` and `apply from: "$publish_jvm_kpsb"`) - Publishing configuration for Kotlin Multiplatform and JVM
-
-### Combined Project Templates
-
-* `mppJvmJsWasmJsLinuxMingwProject.gradle` (usage `apply from: "$mppJvmJsWasmJsLinuxMingwProject"`) - Multiplatform project for JVM, JS, Wasm, Linux, and MinGW
-* `mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle` (usage `apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"`) - Multiplatform project with additional Android and ARM64 support
-* `mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle` (usage `apply from: "$mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"`) - Multiplatform project with Compose support
-* `mppProjectWithSerializationAndCompose.gradle` (usage `apply from: "$mppProjectWithSerializationAndCompose"`) - Multiplatform project with both Serialization and Compose support

build.gradle

@@ -19,30 +19,15 @@ buildscript {
 
 plugins {
     alias(libs.plugins.versions)
-    alias(libs.plugins.nmcp.aggregation)
-}
-
-
-if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-    nmcpAggregation {
-        centralPortal {
-            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-            validationTimeout = Duration.ofHours(4)
-            publishingType = System.getenv('PUBLISHING_TYPE') != "" ? System.getenv('PUBLISHING_TYPE') : "USER_MANAGED"
-        }
-
-        publishAllProjectsProbablyBreakingProjectIsolation()
-    }
 }
 
 allprojects {
     repositories {
+        mavenLocal()
         mavenCentral()
         google()
         maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
         maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
-        mavenLocal()
     }
 }
 

colors/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {

colors/common/build.gradle

@@ -4,4 +4,4 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"

colors/common/src/commonMain/kotlin/HEXAColor.kt

@@ -13,7 +13,7 @@ import kotlin.math.floor
  *
  * Anyway it is recommended to use
  *
- * @param hexaUInt rgba [UInt] in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
+ * @param hexaUInt rgba [UInt] in format `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
  */
 @Serializable
 @JvmInline
@@ -21,18 +21,18 @@ value class HEXAColor (
     val hexaUInt: UInt
 ) : Comparable<HEXAColor> {
     /**
-     * @returns [hexaUInt] as a string with format `#RRGGBBAA` where RR - red, GG - green, BB - blue and AA - alpha
+     * @returns [hexaUInt] as a string with format `#FFEEBBAA` where FF - red, EE - green, BB - blue and AA - alpha
      */
     val hexa: String
         get() = "#${hexaUInt.toString(16).padStart(8, '0')}"
 
     /**
-     * @returns [hexaUInt] as a string with format `#RRGGBB` where RR - red, GG - green and BB - blue
+     * @returns [hexaUInt] as a string with format `#FFEEBB` where FF - red, EE - green and BB - blue
      */
     val hex: String
         get() = hexa.take(7)
     /**
-     * @returns [hexaUInt] as a string with format `#AARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue
+     * @returns [hexaUInt] as a string with format `#AAFFEEBB` where AA - alpha, FF - red, EE - green and BB - blue
      */
     val ahex: String
         get() = "#${a.toString(16).padStart(2, '2')}${hex.drop(1)}"
@@ -140,12 +140,12 @@ value class HEXAColor (
         }.lowercase().toUInt(16).let(::HEXAColor)
 
         /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xRRGGBBAA` where RR - red, GG - green, BB - blue` and AA - alpha
+         * Creates [HEXAColor] from [uint] presume it is in format `0xFFEEBBAA` where FF - red, EE - green, BB - blue` and AA - alpha
          */
         fun fromHexa(uint: UInt) = HEXAColor(uint)
 
         /**
-         * Creates [HEXAColor] from [uint] presume it is in format `0xAARRGGBB` where AA - alpha, RR - red, GG - green and BB - blue`
+         * Creates [HEXAColor] from [uint] presume it is in format `0xAAFFEEBB` where AA - alpha, FF - red, EE - green and BB - blue`
          */
         fun fromAhex(uint: UInt) = HEXAColor(
             a = ((uint and 0xff000000u) / 0x1000000u).toInt(),

common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {
@@ -29,12 +29,5 @@ kotlin {
                 api libs.okio
             }
         }
-
-        wasmJsMain {
-            dependencies {
-                api libs.kotlinx.browser
-                api libs.kt.coroutines
-            }
-        }
     }
 }

common/compose/build.gradle

@@ -6,14 +6,13 @@ plugins {
     alias(libs.plugins.kt.jb.compose)
 }
 
-apply from: "$mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {
         commonMain {
             dependencies {
                 api project(":micro_utils.common")
-                api libs.kt.coroutines
             }
         }
     }

common/compose/src/commonMain/kotlin/dev/inmo/micro_utils/common/compose/LoadableComponent.kt

@@ -1,74 +0,0 @@
-package dev.inmo.micro_utils.common.compose
-
-import androidx.compose.runtime.*
-import dev.inmo.micro_utils.common.Optional
-import dev.inmo.micro_utils.common.dataOrThrow
-import dev.inmo.micro_utils.common.optional
-
-class LoadableComponentContext<T> internal constructor(
-    presetOptional: Optional<T>,
-) {
-    internal val iterationState: MutableState<Int> = mutableStateOf(0)
-
-    internal var dataOptional: Optional<T> = if (presetOptional.dataPresented) presetOptional else Optional.absent()
-        private set
-    internal val dataState: MutableState<Optional<T>> = mutableStateOf(dataOptional)
-
-    fun reload() {
-        iterationState.value++
-    }
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    preload: Optional<T>,
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    val context = remember { LoadableComponentContext(preload) }
-
-    LaunchedEffect(context.iterationState.value) {
-        context.dataState.value = loader(context).optional
-    }
-
-    context.dataState.let {
-        if (it.value.dataPresented) {
-            context.block(it.value.dataOrThrow(IllegalStateException("Data must be presented, but optional has been changed by some way")))
-        }
-    }
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    preload: T,
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    LoadableComponent(preload.optional, loader, block)
-}
-
-/**
- * Showing data with ability to reload data
- *
- * [block] will be shown when [loader] will complete loading. If you want to reload data, just call
- * [LoadableComponentContext.reload]
- */
-@Composable
-fun <T> LoadableComponent(
-    loader: suspend LoadableComponentContext<T>.() -> T,
-    block: @Composable LoadableComponentContext<T>.(T) -> Unit
-) {
-    LoadableComponent(Optional.absent(), loader, block)
-}

common/compose/src/jvmTest/kotlin/LoadableComponentTests.kt

@@ -1,42 +0,0 @@
-import androidx.compose.runtime.remember
-import androidx.compose.ui.test.ExperimentalTestApi
-import androidx.compose.ui.test.runComposeUiTest
-import dev.inmo.micro_utils.common.compose.LoadableComponent
-import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.firstOrNull
-import org.jetbrains.annotations.TestOnly
-import kotlin.test.Test
-import kotlin.test.assertTrue
-
-class LoadableComponentTests {
-    @OptIn(ExperimentalTestApi::class)
-    @Test
-    @TestOnly
-    fun testSimpleLoad() = runComposeUiTest {
-        val loadingFlow = SpecialMutableStateFlow<Int>(0)
-        val loadedFlow = SpecialMutableStateFlow<Int>(0)
-        setContent {
-            LoadableComponent<Int>({
-                loadingFlow.filter { it == 1 }.first()
-            }) {
-                assert(dataState.value.data == 1)
-                remember {
-                    loadedFlow.value = 2
-                }
-            }
-        }
-
-        waitForIdle()
-
-        assertTrue(loadedFlow.value == 0)
-
-        loadingFlow.value = 1
-
-        waitForIdle()
-
-        assertTrue(loadedFlow.value == 2)
-    }
-}

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/Comparator.kt

@@ -1,6 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
- */
-fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/MapDiff.kt

@@ -82,11 +82,13 @@ fun <K, V> MutableMap<K, V>.applyDiff(
     mapDiff: MapDiff<K, V>
 ) {
     mapDiff.apply {
-        keys.removeAll(removed.keys)
+        removed.keys.forEach { remove(it) }
         changed.forEach { (k, oldNew) ->
             put(k, oldNew.second)
         }
-        putAll(added)
+        added.forEach { (k, new) ->
+            put(k, new)
+        }
     }
 }
 

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/Retry.kt

@@ -1,26 +0,0 @@
-package dev.inmo.micro_utils.common
-
-/**
- * Will try to execute [action] and, if any exception will happen, execution will be retried.
- * This process will happen at most [count] times. There is no any limits on [count] value, but [action] will run at
- * least once and [retryOnFailure] will return its result if it is successful
- */
-inline fun <T> retryOnFailure(count: Int, action: () -> T): T {
-    var triesCount = 0
-    while (true) {
-        val result = runCatching {
-            action()
-        }.onFailure {
-            triesCount++
-
-            if (triesCount >= count) {
-                throw it
-            } else {
-                null
-            }
-        }
-
-        if (result.isSuccess) return result.getOrThrow()
-    }
-    error("Unreachable code: retry must throw latest exception if error happen or success value if not")
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/ByteArrayDataView.kt

@@ -1,15 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.khronos.webgl.*
-
-fun DataView.toByteArray() = ByteArray(this.byteLength) {
-    getInt8(it)
-}
-
-fun ArrayBuffer.toByteArray() = Int8Array(this).toByteArray()
-
-fun ByteArray.toDataView() = DataView(ArrayBuffer(size)).also {
-    forEachIndexed { i, byte -> it.setInt8(i, byte) }
-}
-
-fun ByteArray.toArrayBuffer() = toDataView().buffer

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/CopyToClipboard.kt

@@ -1,13 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-
-fun copyToClipboard(text: String): Boolean {
-    return runCatching {
-        window.navigator.clipboard.writeText(
-            text
-        )
-    }.onFailure {
-        it.printStackTrace()
-    }.isSuccess
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/CopyToClipboardImage.kt

@@ -1,31 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-import kotlinx.coroutines.await
-import org.w3c.fetch.Response
-import org.w3c.files.Blob
-import org.w3c.files.BlobPropertyBag
-
-external class ClipboardItem(data: JsAny?) : JsAny
-
-fun createBlobData(blob: Blob): JsAny = js("""({[blob.type]: blob})""")
-
-inline fun Blob.convertToClipboardItem(): ClipboardItem {
-    return ClipboardItem(createBlobData(this))
-}
-
-suspend fun copyImageURLToClipboard(imageUrl: String): Boolean {
-    return runCatching {
-        val response = window.fetch(imageUrl).await<Response>()
-        val blob = response.blob().await<Blob>()
-        val data = arrayOf(
-            Blob(
-                arrayOf(blob).toJsArray().unsafeCast(),
-                BlobPropertyBag("image/png")
-            ).convertToClipboardItem()
-        ).toJsArray()
-        window.navigator.clipboard.write(data.unsafeCast())
-    }.onFailure {
-        it.printStackTrace()
-    }.isSuccess
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/HTMLElementDomChanged.kt

@@ -1,63 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.document
-import org.w3c.dom.*
-
-private fun createMutationObserverInit(childList: Boolean, subtree: Boolean): JsAny = js("({childList, subtree})")
-
-fun Node.onRemoved(block: () -> Unit): MutationObserver {
-    lateinit var observer: MutationObserver
-
-    observer = MutationObserver { _, _ ->
-        fun checkIfRemoved(node: Node): Boolean {
-            return node.parentNode != document && (node.parentNode ?.let { checkIfRemoved(it) } ?: true)
-        }
-
-        if (checkIfRemoved(this)) {
-            observer.disconnect()
-            block()
-        }
-    }
-
-    observer.observe(document, createMutationObserverInit(childList = true, subtree = true).unsafeCast())
-    return observer
-}
-
-fun Element.onVisibilityChanged(block: IntersectionObserverEntry.(Float, IntersectionObserver) -> Unit): IntersectionObserver {
-    var previousIntersectionRatio = -1f
-    val observer = IntersectionObserver { entries, observer ->
-        entries.toArray().forEach {
-            if (previousIntersectionRatio.toDouble() != it.intersectionRatio.toDouble()) {
-                previousIntersectionRatio = it.intersectionRatio.toDouble().toFloat()
-                it.block(previousIntersectionRatio, observer)
-            }
-        }
-    }
-
-    observer.observe(this)
-    return observer
-}
-
-fun Element.onVisible(block: Element.(IntersectionObserver) -> Unit) {
-    var previous = -1f
-    onVisibilityChanged { intersectionRatio, observer ->
-        if (previous != intersectionRatio) {
-            if (intersectionRatio > 0 && previous == 0f) {
-                block(observer)
-            }
-            previous = intersectionRatio
-        }
-    }
-}
-
-fun Element.onInvisible(block: Element.(IntersectionObserver) -> Unit): IntersectionObserver {
-    var previous = -1f
-    return onVisibilityChanged { intersectionRatio, observer ->
-        if (previous != intersectionRatio) {
-            if (intersectionRatio == 0f && previous != 0f) {
-                block(observer)
-            }
-            previous = intersectionRatio
-        }
-    }
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/HtmlElementOnScreen.kt

@@ -1,43 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-import org.w3c.dom.DOMRect
-import org.w3c.dom.Element
-
-val DOMRect.isOnScreenByLeftEdge: Boolean
-    get() = left >= 0 && left <= window.innerWidth
-inline val Element.isOnScreenByLeftEdge
-    get() = getBoundingClientRect().isOnScreenByLeftEdge
-
-val DOMRect.isOnScreenByRightEdge: Boolean
-    get() = right >= 0 && right <= window.innerWidth
-inline val Element.isOnScreenByRightEdge
-    get() = getBoundingClientRect().isOnScreenByRightEdge
-
-internal val DOMRect.isOnScreenHorizontally: Boolean
-    get() = isOnScreenByLeftEdge || isOnScreenByRightEdge
-
-
-val DOMRect.isOnScreenByTopEdge: Boolean
-    get() = top >= 0 && top <= window.innerHeight
-inline val Element.isOnScreenByTopEdge
-    get() = getBoundingClientRect().isOnScreenByTopEdge
-
-val DOMRect.isOnScreenByBottomEdge: Boolean
-    get() = bottom >= 0 && bottom <= window.innerHeight
-inline val Element.isOnScreenByBottomEdge
-    get() = getBoundingClientRect().isOnScreenByBottomEdge
-
-internal val DOMRect.isOnScreenVertically: Boolean
-    get() = isOnScreenByLeftEdge || isOnScreenByRightEdge
-
-
-val DOMRect.isOnScreenFully: Boolean
-    get() = isOnScreenByLeftEdge && isOnScreenByTopEdge && isOnScreenByRightEdge && isOnScreenByBottomEdge
-val Element.isOnScreenFully: Boolean
-    get() = getBoundingClientRect().isOnScreenFully
-
-val DOMRect.isOnScreen: Boolean
-    get() = isOnScreenFully || (isOnScreenHorizontally && isOnScreenVertically)
-inline val Element.isOnScreen: Boolean
-    get() = getBoundingClientRect().isOnScreen

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/IntersectionObserver.kt

@@ -1,127 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.w3c.dom.DOMRectReadOnly
-import org.w3c.dom.Element
-
-external interface IntersectionObserverOptions: JsAny {
-    /**
-     * An Element or Document object which is an ancestor of the intended target, whose bounding rectangle will be
-     * considered the viewport. Any part of the target not visible in the visible area of the root is not considered
-     * visible.
-     */
-    var root: Element?
-
-    /**
-     * A string which specifies a set of offsets to add to the root's bounding_box when calculating intersections,
-     * effectively shrinking or growing the root for calculation purposes. The syntax is approximately the same as that
-     * for the CSS margin property; see The root element and root margin in Intersection Observer API for more
-     * information on how the margin works and the syntax. The default is "0px 0px 0px 0px".
-     */
-    var rootMargin: String?
-
-    /**
-     * Either a single number or an array of numbers between 0.0 and 1.0, specifying a ratio of intersection area to
-     * total bounding box area for the observed target. A value of 0.0 means that even a single visible pixel counts as
-     * the target being visible. 1.0 means that the entire target element is visible. See Thresholds in Intersection
-     * Observer API for a more in-depth description of how thresholds are used. The default is a threshold of 0.0.
-     */
-    var threshold: JsArray<JsNumber>?
-}
-
-private fun createEmptyJsObject(): JsAny = js("{}")
-
-fun IntersectionObserverOptions(
-    block: IntersectionObserverOptions.() -> Unit = {}
-): IntersectionObserverOptions = createEmptyJsObject().unsafeCast<IntersectionObserverOptions>().apply(block)
-
-external interface IntersectionObserverEntry: JsAny {
-    /**
-     * Returns the bounds rectangle of the target element as a DOMRectReadOnly. The bounds are computed as described in
-     * the documentation for Element.getBoundingClientRect().
-     */
-    val boundingClientRect: DOMRectReadOnly
-
-    /**
-     * Returns the ratio of the intersectionRect to the boundingClientRect.
-     */
-    val intersectionRatio: JsNumber
-
-    /**
-     * Returns a DOMRectReadOnly representing the target's visible area.
-     */
-    val intersectionRect: DOMRectReadOnly
-
-    /**
-     * A Boolean value which is true if the target element intersects with the intersection observer's root. If this is
-     * true, then, the IntersectionObserverEntry describes a transition into a state of intersection; if it's false,
-     * then you know the transition is from intersecting to not-intersecting.
-     */
-    val isIntersecting: Boolean
-
-    /**
-     * Returns a DOMRectReadOnly for the intersection observer's root.
-     */
-    val rootBounds: DOMRectReadOnly
-
-    /**
-     * The Element whose intersection with the root changed.
-     */
-    val target: Element
-
-    /**
-     * A DOMHighResTimeStamp indicating the time at which the intersection was recorded, relative to the
-     * IntersectionObserver's time origin.
-     */
-    val time: Double
-}
-
-typealias IntersectionObserverCallback = (entries: JsArray<IntersectionObserverEntry>, observer: IntersectionObserver) -> Unit
-
-/**
- * This is just an implementation from [this commentary](https://youtrack.jetbrains.com/issue/KT-43157#focus=Comments-27-4498582.0-0)
- * of Kotlin JS issue related to the absence of [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver)
- */
-external class IntersectionObserver(callback: IntersectionObserverCallback): JsAny {
-    constructor(callback: IntersectionObserverCallback, options: IntersectionObserverOptions)
-
-    /**
-     * The Element or Document whose bounds are used as the bounding box when testing for intersection. If no root value
-     * was passed to the constructor or its value is null, the top-level document's viewport is used.
-     */
-    val root: Element
-
-    /**
-     * An offset rectangle applied to the root's bounding box when calculating intersections, effectively shrinking or
-     * growing the root for calculation purposes. The value returned by this property may not be the same as the one
-     * specified when calling the constructor as it may be changed to match internal requirements. Each offset can be
-     * expressed in pixels (px) or as a percentage (%). The default is "0px 0px 0px 0px".
-     */
-    val rootMargin: String
-
-    /**
-     * A list of thresholds, sorted in increasing numeric order, where each threshold is a ratio of intersection area to
-     * bounding box area of an observed target. Notifications for a target are generated when any of the thresholds are
-     * crossed for that target. If no value was passed to the constructor, 0 is used.
-     */
-    val thresholds: JsArray<JsNumber>
-
-    /**
-     * Stops the IntersectionObserver object from observing any target.
-     */
-    fun disconnect()
-
-    /**
-     * Tells the IntersectionObserver a target element to observe.
-     */
-    fun observe(targetElement: Element)
-
-    /**
-     * Returns an array of IntersectionObserverEntry objects for all observed targets.
-     */
-    fun takeRecords(): JsArray<IntersectionObserverEntry>
-
-    /**
-     * Tells the IntersectionObserver to stop observing a particular target element.
-     */
-    fun unobserve(targetElement: Element)
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/IsOverflow.kt

@@ -1,12 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.w3c.dom.Element
-
-inline val Element.isOverflowWidth
-    get() = scrollWidth > clientWidth
-
-inline val Element.isOverflowHeight
-    get() = scrollHeight > clientHeight
-
-inline val Element.isOverflow
-    get() = isOverflowHeight || isOverflowWidth

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/JSMPPFile.kt

@@ -1,58 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.coroutines.await
-import org.khronos.webgl.ArrayBuffer
-import org.w3c.dom.ErrorEvent
-import org.w3c.files.*
-import kotlin.js.Promise
-
-/**
- * @suppress
- */
-actual typealias MPPFile = File
-
-private fun createJsError(message: String): JsAny = js("Error(message)")
-
-fun MPPFile.readBytesPromise() = Promise { success, failure ->
-    val reader = FileReader()
-    reader.onload = {
-        success((reader.result as ArrayBuffer))
-    }
-    reader.onerror = {
-        val message = (it as ErrorEvent).message
-        failure(createJsError(message))
-    }
-    reader.readAsArrayBuffer(this)
-}
-
-fun MPPFile.readBytes(): ByteArray {
-    val reader = FileReaderSync()
-    return reader.readAsArrayBuffer(this).toByteArray()
-}
-
-private suspend fun MPPFile.dirtyReadBytes(): ByteArray = readBytesPromise().await<ArrayBuffer>().toByteArray()
-
-/**
- * @suppress
- */
-actual val MPPFile.filename: FileName
-    get() = FileName(name)
-/**
- * @suppress
- */
-actual val MPPFile.filesize: Long
-    get() = jsNumberToBigInt(size).toLong()
-/**
- * @suppress
- */
-@Warning("That is not optimized version of bytes allocator. Use asyncBytesAllocator everywhere you can")
-actual val MPPFile.bytesAllocatorSync: ByteArrayAllocator
-    get() = ::readBytes
-/**
- * @suppress
- */
-@Warning("That is not optimized version of bytes allocator. Use asyncBytesAllocator everywhere you can")
-actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
-    get() = ::dirtyReadBytes
-
-private fun jsNumberToBigInt(number: JsNumber): JsBigInt = js("BigInt(number)")

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/OnClickOutside.kt

@@ -1,41 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.document
-import org.w3c.dom.*
-import org.w3c.dom.events.Event
-import org.w3c.dom.events.EventListener
-
-private fun createEventListener(listener: (Event) -> Unit): JsAny = js("({handleEvent: listener})")
-
-fun Element.onActionOutside(type: String, options: AddEventListenerOptions? = null, callback: (Event) -> Unit): EventListener {
-    lateinit var observer: MutationObserver
-    val listener = createEventListener { it: Event ->
-        val elementsToCheck = mutableListOf(this@onActionOutside)
-        while (it.target != this@onActionOutside && elementsToCheck.isNotEmpty()) {
-            val childrenGettingElement = elementsToCheck.removeFirst()
-            for (i in 0 until childrenGettingElement.childElementCount) {
-                elementsToCheck.add(childrenGettingElement.children[i] ?: continue)
-            }
-        }
-        if (elementsToCheck.isEmpty()) {
-            callback(it)
-        }
-    }.unsafeCast<EventListener>()
-
-    if (options == null) {
-        document.addEventListener(type, listener)
-    } else {
-        document.addEventListener(type, listener, options)
-    }
-    observer = onRemoved {
-        if (options == null) {
-            document.removeEventListener(type, listener)
-        } else {
-            document.removeEventListener(type, listener, options)
-        }
-        observer.disconnect()
-    }
-    return listener
-}
-
-fun Element.onClickOutside(options: AddEventListenerOptions? = null, callback: (Event) -> Unit) = onActionOutside("click", options, callback)

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/OpenLink.kt

@@ -1,8 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-
-fun openLink(link: String, target: String = "_blank", features: String = "") {
-    window.open(link, target, features) ?.focus()
-}
-

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/ResizeObserver.kt

@@ -1,56 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.w3c.dom.*
-
-external class ResizeObserver(
-    callback: (JsArray<ResizeObserverEntry>, ResizeObserver) -> Unit
-): JsAny {
-    fun observe(target: Element, options: JsAny = definedExternally)
-
-    fun unobserve(target: Element)
-
-    fun disconnect()
-}
-
-private fun createObserveOptions(jsBox: JsString?): JsAny = js("({box: jsBox})")
-
-external interface ResizeObserverSize: JsAny {
-    val blockSize: Float
-    val inlineSize: Float
-}
-
-external interface ResizeObserverEntry: JsAny {
-    val borderBoxSize: JsArray<ResizeObserverSize>
-    val contentBoxSize: JsArray<ResizeObserverSize>
-    val devicePixelContentBoxSize: JsArray<ResizeObserverSize>
-    val contentRect: DOMRectReadOnly
-    val target: Element
-}
-
-fun ResizeObserver.observe(target: Element, options: ResizeObserverObserveOptions) = observe(
-    target,
-    createObserveOptions(options.box?.name?.toJsString())
-)
-
-class ResizeObserverObserveOptions(
-    val box: Box? = null
-) {
-    sealed interface Box {
-        val name: String
-
-        object Content : Box {
-            override val name: String
-                get() = "content-box"
-        }
-
-        object Border : Box {
-            override val name: String
-                get() = "border-box"
-        }
-
-        object DevicePixelContent : Box {
-            override val name: String
-                get() = "device-pixel-content-box"
-        }
-    }
-}

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/SelectFile.kt

@@ -1,30 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.document
-import kotlinx.dom.createElement
-import org.w3c.dom.HTMLElement
-import org.w3c.dom.HTMLInputElement
-import org.w3c.files.get
-
-fun selectFile(
-    inputSetup: (HTMLInputElement) -> Unit = {},
-    onFailure: (Throwable) -> Unit = {},
-    onFile: (MPPFile) -> Unit
-) {
-    (document.createElement("input") {
-        (this as HTMLInputElement).apply {
-            type = "file"
-            onchange = {
-                runCatching {
-                    files ?.get(0) ?: error("File must not be null")
-                }.onSuccess {
-                    onFile(it)
-                }.onFailure {
-                    onFailure(it)
-                }
-            }
-            inputSetup(this)
-        }
-    } as HTMLElement).click()
-}
-

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/TriggerDownload.kt

@@ -1,14 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.document
-import org.w3c.dom.HTMLAnchorElement
-
-fun triggerDownloadFile(filename: String, fileLink: String) {
-    val hiddenElement = document.createElement("a") as HTMLAnchorElement
-
-    hiddenElement.href = fileLink
-    hiddenElement.target = "_blank"
-    hiddenElement.download = filename
-    hiddenElement.click()
-}
-

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/Visibility.kt

@@ -1,48 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.window
-import org.w3c.dom.Element
-import org.w3c.dom.css.CSSStyleDeclaration
-
-sealed class Visibility
-data object Visible : Visibility()
-data object Invisible : Visibility()
-data object Gone : Visibility()
-
-var CSSStyleDeclaration.visibilityState: Visibility
-    get() = when {
-        display == "none" -> Gone
-        visibility == "hidden" -> Invisible
-        else -> Visible
-    }
-    set(value) {
-        when (value) {
-            Visible -> {
-                if (display == "none") {
-                    display = "initial"
-                }
-                visibility = "visible"
-            }
-            Invisible -> {
-                if (display == "none") {
-                    display = "initial"
-                }
-                visibility = "hidden"
-            }
-            Gone -> {
-                display = "none"
-            }
-        }
-    }
-inline var Element.visibilityState: Visibility
-    get() = window.getComputedStyle(this).visibilityState
-    set(value) {
-        window.getComputedStyle(this).visibilityState = value
-    }
-
-inline val Element.isVisible: Boolean
-    get() = visibilityState == Visible
-inline val Element.isInvisible: Boolean
-    get() = visibilityState == Invisible
-inline val Element.isGone: Boolean
-    get() = visibilityState == Gone

common/src/wasmJsMain/kotlin/dev/inmo/micro_utils/common/toFixed.kt

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.common
-
-actual fun Float.fixed(signs: Int): Float {
-    return jsToFixed(toDouble().toJsNumber(), signs.coerceIn(FixedSignsRange)).toString().toFloat()
-}
-
-actual fun Double.fixed(signs: Int): Double {
-    return jsToFixed(toJsNumber(), signs.coerceIn(FixedSignsRange)).toString().toDouble()
-}
-
-private fun jsToFixed(number: JsNumber, signs: Int): JsString = js("number.toFixed(signs)")

coroutines/build.gradle

@@ -4,14 +4,13 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {
         commonMain {
             dependencies {
                 api libs.kt.coroutines
-                api libs.kslog
             }
         }
         jsMain {

coroutines/compose/build.gradle

@@ -6,7 +6,7 @@ plugins {
     alias(libs.plugins.kt.jb.compose)
 }
 
-apply from: "$mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/Actor.kt

@@ -4,15 +4,6 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.consumeAsFlow
 
-/**
- * Creates an actor using coroutines that processes incoming messages of type [T].
- * An actor is a computational entity that processes messages sequentially in response to messages it receives.
- *
- * @param T The type of messages this actor will process
- * @param channelCapacity The capacity of the [Channel] used for message delibery to the actor. Defaults to [Channel.UNLIMITED]
- * @param block The processing logic to be applied to each received message
- * @return A [Channel] that can be used to send messages to this actor or cancel it
- */
 fun <T> CoroutineScope.actor(
     channelCapacity: Int = Channel.UNLIMITED,
     block: suspend (T) -> Unit
@@ -22,16 +13,6 @@ fun <T> CoroutineScope.actor(
     return channel
 }
 
-/**
- * Creates a safe actor that catches and handles exceptions during message processing.
- * This variant wraps the processing logic in a safety mechanism to prevent actor failure due to exceptions.
- *
- * @param T The type of messages this actor will process
- * @param channelCapacity The capacity of the [Channel] used for message processing. Defaults to [Channel.UNLIMITED]
- * @param onException Handler for exceptions that occur during message processing. Defaults to [defaultSafelyExceptionHandler]
- * @param block The processing logic to be applied to each received message
- * @return A [Channel] that can be used to send messages to this actor
- */
 inline fun <T> CoroutineScope.safeActor(
     channelCapacity: Int = Channel.UNLIMITED,
     noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/ContextSafelyExceptionHandler.kt

@@ -41,4 +41,4 @@ class ContextSafelyExceptionHandler(
 ) : CoroutineContext.Element {
     override val key: CoroutineContext.Key<*>
         get() = ContextSafelyExceptionHandlerKey
-}
+}

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowSubscription.kt

@@ -2,7 +2,6 @@
 
 package dev.inmo.micro_utils.coroutines
 
-import dev.inmo.kslog.common.KSLog
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
@@ -17,45 +16,6 @@ inline fun <T> Flow<T>.subscribe(scope: CoroutineScope, noinline block: suspend
  * Use [subscribe], but all [block]s will be called inside of [safely] function.
  * Use [onException] to set up your reaction for [Throwable]s
  */
-inline fun <T> Flow<T>.subscribeLogging(
-    scope: CoroutineScope,
-    noinline errorMessageBuilder: T.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    noinline block: suspend (T) -> Unit
-) = subscribe(scope) {
-    it.runCatchingLogging(
-        errorMessageBuilder,
-        logger
-    ) {
-        block(it)
-    }.getOrThrow()
-}
-
-/**
- * Use [subscribeSafelyWithoutExceptions], but all exceptions will be passed to [defaultSafelyExceptionHandler]
- */
-inline fun <T> Flow<T>.subscribeLoggingDropExceptions(
-    scope: CoroutineScope,
-    noinline errorMessageBuilder: T.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    noinline block: suspend (T) -> Unit
-) = subscribe(scope) {
-    it.runCatchingLogging(
-        errorMessageBuilder,
-        logger
-    ) {
-        block(it)
-    }
-}
-
-/**
- * Use [subscribe], but all [block]s will be called inside of [safely] function.
- * Use [onException] to set up your reaction for [Throwable]s
- */
-@Deprecated(
-    "Will be removed soon due to replacement by subscribeLogging",
-    ReplaceWith("this.subscribeLogging(scope = scope, block = block)")
-)
 inline fun <T> Flow<T>.subscribeSafely(
     scope: CoroutineScope,
     noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
@@ -69,10 +29,6 @@ inline fun <T> Flow<T>.subscribeSafely(
 /**
  * Use [subscribeSafelyWithoutExceptions], but all exceptions will be passed to [defaultSafelyExceptionHandler]
  */
-@Deprecated(
-    "Will be removed soon due to replacement by subscribeLoggingDropExceptions",
-    ReplaceWith("this.subscribeLoggingDropExceptions(scope = scope, block = block)")
-)
 inline fun <T> Flow<T>.subscribeSafelyWithoutExceptions(
     scope: CoroutineScope,
     noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
@@ -86,10 +42,6 @@ inline fun <T> Flow<T>.subscribeSafelyWithoutExceptions(
 /**
  * Use [subscribeSafelyWithoutExceptions], but all exceptions inside of [safely] will be skipped
  */
-@Deprecated(
-    "Will be removed soon due to replacement by subscribeLoggingDropExceptions",
-    ReplaceWith("this.subscribeLoggingDropExceptions(scope = scope, block = block)")
-)
 inline fun <T> Flow<T>.subscribeSafelySkippingExceptions(
     scope: CoroutineScope,
     noinline block: suspend (T) -> Unit

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowSubscriptionAsync.kt

@@ -15,7 +15,7 @@ private class SubscribeAsyncReceiver<T>(
         get() = dataChannel
 
     init {
-        scope.launchLoggingDropExceptions {
+        scope.launchSafelyWithoutExceptions {
             for (data in dataChannel) {
                 output(data)
             }
@@ -71,7 +71,7 @@ fun <T, M> Flow<T>.subscribeAsync(
         it.invoke(markersMap)
     }
 
-    val job = subscribeLoggingDropExceptions(subscope) { data ->
+    val job = subscribeSafelyWithoutExceptions(subscope) { data ->
         val dataCommand = AsyncSubscriptionCommandData(data, subscope, markerFactory, block) { marker ->
             actor.send(
                 AsyncSubscriptionCommandClearReceiver(marker)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt

@@ -15,10 +15,6 @@ import kotlin.coroutines.coroutineContext
  *
  * @return [Result] with result of [block] if no exceptions or [Result] from [onException] execution
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { onException(it) }")
-)
 suspend inline fun <T> runCatchingSafely(
     onException: ExceptionHandler<T>,
     block: suspend () -> T
@@ -33,10 +29,6 @@ suspend inline fun <T> runCatchingSafely(
     }
 }
 
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { onException(it) }")
-)
 suspend inline fun <T, R> R.runCatchingSafely(
     onException: ExceptionHandler<T>,
     block: suspend R.() -> T
@@ -47,18 +39,10 @@ suspend inline fun <T, R> R.runCatchingSafely(
 /**
  * Launching [runCatchingSafely] with [defaultSafelyExceptionHandler] as `onException` parameter
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { defaultSafelyExceptionHandler(it) }")
-)
 suspend inline fun <T> runCatchingSafely(
     block: suspend () -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
 
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { defaultSafelyExceptionHandler(it) }")
-)
 suspend inline fun <T, R> R.runCatchingSafely(
     block: suspend R.() -> T
 ): Result<T> = runCatchingSafely<T> {
@@ -89,9 +73,6 @@ suspend fun contextSafelyExceptionHandler() = coroutineContext[ContextSafelyExce
  * After all, will be called [withContext] method with created [ContextSafelyExceptionHandler] and block which will call
  * [safely] method with [safelyExceptionHandler] as onException parameter and [block] as execution block
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-)
 suspend fun <T> safelyWithContextExceptionHandler(
     contextExceptionHandler: ExceptionHandler<Unit>,
     safelyExceptionHandler: ExceptionHandler<T> = defaultSafelyExceptionHandler,
@@ -113,10 +94,6 @@ suspend fun <T> safelyWithContextExceptionHandler(
  *
  * @see runCatchingSafely
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { onException(it) }.getOrThrow()")
-)
 suspend inline fun <T> safely(
     onException: ExceptionHandler<T>,
     block: suspend () -> T
@@ -127,17 +104,9 @@ suspend inline fun <T> safely(
  *
  * @see runCatchingSafely
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { defaultSafelyExceptionHandler(it) }.getOrThrow()")
-)
 suspend inline fun <T> safely(
     block: suspend () -> T
 ): T = safely(defaultSafelyExceptionHandler, block)
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { defaultSafelyExceptionHandler(it) }.getOrThrow()")
-)
 suspend inline fun <T, R> R.safely(
     block: suspend R.() -> T
 ): T = safely<T> { block() }
@@ -168,19 +137,11 @@ val defaultSafelyWithoutExceptionHandlerWithNull: ExceptionHandler<Nothing?> = {
  * Shortcut for [safely] with exception handler, that as expected must return null in case of impossible creating of
  * result from exception (instead of throwing it, by default always returns null)
  */
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { onException(it) }.getOrNull()")
-)
 suspend fun <T> safelyWithoutExceptions(
     onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
     block: suspend () -> T
 ): T? = runCatchingSafely(onException, block).getOrNull()
 
-@Deprecated(
-    "This function become redundant since coroutines correctly handling throwing exceptions",
-    replaceWith = ReplaceWith("runCatching(block).replaceIfFailure { onException(it) }.getOrNull()")
-)
 suspend fun <T> runCatchingSafelyWithoutExceptions(
     onException: ExceptionHandler<T?> = defaultSafelyExceptionHandler,
     block: suspend () -> T

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchLogging.kt

@@ -1,55 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.e
-import kotlinx.coroutines.*
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-
-fun CoroutineScope.launchLogging(
-    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    context: CoroutineContext = EmptyCoroutineContext,
-    start: CoroutineStart = CoroutineStart.DEFAULT,
-    block: suspend CoroutineScope.() -> Unit
-) = launch(context, start) {
-    runCatching { block() }.onFailure {
-        logger.e(it) { errorMessageBuilder(it) }
-    }.getOrThrow()
-}
-
-fun CoroutineScope.launchLoggingDropExceptions(
-    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    context: CoroutineContext = EmptyCoroutineContext,
-    start: CoroutineStart = CoroutineStart.DEFAULT,
-    block: suspend CoroutineScope.() -> Unit
-) = launch(context, start) {
-    runCatching { block() }.onFailure {
-        logger.e(it) { errorMessageBuilder(it) }
-    } // just dropping exception
-}
-
-fun <T> CoroutineScope.asyncLogging(
-    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    context: CoroutineContext = EmptyCoroutineContext,
-    start: CoroutineStart = CoroutineStart.DEFAULT,
-    block: suspend CoroutineScope.() -> T
-) = async(context, start) {
-    runCatching { block() }.onFailure {
-        logger.e(it) { errorMessageBuilder(it) }
-    }.getOrThrow()
-}
-
-fun <T> CoroutineScope.asyncLoggingDropExceptions(
-    errorMessageBuilder: CoroutineScope.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    context: CoroutineContext = EmptyCoroutineContext,
-    start: CoroutineStart = CoroutineStart.DEFAULT,
-    block: suspend CoroutineScope.() -> T
-) = async(context, start) {
-    runCatching { block() }.onFailure {
-        logger.e(it) { errorMessageBuilder(it) }
-    }
-}

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSafely.kt

@@ -4,10 +4,6 @@ import kotlinx.coroutines.*
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-@Deprecated(
-    "This method will be removed soon. Use launchLogging instead",
-    ReplaceWith("this.launchLogging(context = context, start = start, block = block)")
-)
 fun CoroutineScope.launchSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
@@ -19,10 +15,6 @@ fun CoroutineScope.launchSafely(
     }
 }
 
-@Deprecated(
-    "This method will be removed soon. Use launchLoggingDropExceptions instead",
-    ReplaceWith("this.launchLoggingDropExceptions(context = context, start = start, block = block)")
-)
 fun CoroutineScope.launchSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
@@ -34,10 +26,6 @@ fun CoroutineScope.launchSafelyWithoutExceptions(
     }
 }
 
-@Deprecated(
-    "This method will be removed soon. Use asyncLogging instead",
-    ReplaceWith("this.asyncLogging(context = context, start = start, block = block)")
-)
 fun <T> CoroutineScope.asyncSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
@@ -49,10 +37,6 @@ fun <T> CoroutineScope.asyncSafely(
     }
 }
 
-@Deprecated(
-    "This method will be removed soon. Use asyncLoggingDropExceptions instead",
-    ReplaceWith("this.asyncLoggingDropExceptions(context = context, start = start, block = block)")
-)
 fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/ReplaceResult.kt

@@ -1,3 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-inline fun <T> Result<T>.replaceIfFailure(onException: (Throwable) -> T) = if (isSuccess) { this } else { runCatching { onException(exceptionOrNull()!!) } }

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/RunCatchingLogging.kt

@@ -1,12 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.e
-
-inline fun <T, R> R.runCatchingLogging(
-    noinline errorMessageBuilder: R.(Throwable) -> Any = { "Something web wrong" },
-    logger: KSLog = KSLog,
-    block: R.() -> T
-) = runCatching(block).onFailure {
-    logger.e(it) { errorMessageBuilder(it) }
-}

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/SmartKeyRWLocker.kt

@@ -1,226 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-/**
- * Combining [globalRWLocker] and internal map of [SmartRWLocker] associated by [T] to provide next logic:
- *
- * * Locker by key, for reading: waiting for [globalRWLocker] unlock write by acquiring read permit in it and then
- * taking or creating locker for key [T] and lock its reading too
- * * Locker by key, for writing: waiting for [globalRWLocker] unlock write by acquiring read permit in it and then
- * taking or creating locker for key [T] and lock its writing
- * * [globalRWLocker], for reading: using [SmartRWLocker.acquireRead], will be suspended until its
- * [SmartRWLocker.lockWrite] will not be unlocked
- * * [globalRWLocker], for writing: using [SmartRWLocker.lockWrite], will be paused by other reading and writing
- * operations and will pause other operations until the end of operation (calling of [unlockWrite])
- *
- * You may see, that lockers by key still will use global locker permits - it is required to prevent [globalRWLocker]
- * write locking during all other operations are not done. In fact, all the keys works like a simple [SmartRWLocker] as
- * well, as [globalRWLocker], but they are linked with [globalRWLocker] [SmartRWLocker.acquireRead] permissions
- */
-class SmartKeyRWLocker<T>(
-    globalLockerReadPermits: Int = Int.MAX_VALUE,
-    globalLockerWriteIsLocked: Boolean = false,
-    private val perKeyReadPermits: Int = Int.MAX_VALUE
-) {
-    private val globalRWLocker: SmartRWLocker = SmartRWLocker(
-        readPermits = globalLockerReadPermits,
-        writeIsLocked = globalLockerWriteIsLocked
-    )
-    private val lockers = mutableMapOf<T, SmartRWLocker>()
-    private val lockersMutex = Mutex()
-    private val lockersWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
-    private val globalWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
-
-    private fun allocateLockerWithoutLock(key: T) = lockers.getOrPut(key) {
-        SmartRWLocker(perKeyReadPermits)
-    }
-    private suspend fun allocateLocker(key: T) = lockersMutex.withLock {
-        lockers.getOrPut(key) {
-            SmartRWLocker(perKeyReadPermits)
-        }
-    }
-
-    suspend fun writeMutex(key: T): SmartMutex.Immutable = globalRWLocker.withReadAcquire {
-        allocateLockerWithoutLock(key).writeMutex
-    }
-    suspend fun readSemaphore(key: T): SmartSemaphore.Immutable = globalRWLocker.withReadAcquire {
-        allocateLockerWithoutLock(key).readSemaphore
-    }
-    fun writeMutexOrNull(key: T): SmartMutex.Immutable? = lockers[key] ?.writeMutex
-    fun readSemaphoreOrNull(key: T): SmartSemaphore.Immutable? = lockers[key] ?.readSemaphore
-
-    fun writeMutex(): SmartMutex.Immutable = globalRWLocker.writeMutex
-    fun readSemaphore(): SmartSemaphore.Immutable = globalRWLocker.readSemaphore
-
-    suspend fun acquireRead() {
-        globalWritingLocker.acquire()
-        try {
-            lockersWritingLocker.waitReleaseAll()
-            globalRWLocker.acquireRead()
-        } catch (e: CancellationException) {
-            globalWritingLocker.release()
-            throw e
-        }
-    }
-    suspend fun releaseRead(): Boolean {
-        globalWritingLocker.release()
-        return globalRWLocker.releaseRead()
-    }
-
-    suspend fun lockWrite() {
-        globalRWLocker.lockWrite()
-    }
-    suspend fun unlockWrite(): Boolean {
-        return globalRWLocker.unlockWrite()
-    }
-    fun isWriteLocked(): Boolean = globalRWLocker.writeMutex.isLocked == true
-
-
-    suspend fun acquireRead(key: T) {
-        globalRWLocker.acquireRead()
-        val locker = allocateLocker(key)
-        try {
-            locker.acquireRead()
-        } catch (e: CancellationException) {
-            globalRWLocker.releaseRead()
-            throw e
-        }
-    }
-    suspend fun releaseRead(key: T): Boolean {
-        val locker = allocateLocker(key)
-        return locker.releaseRead() && globalRWLocker.releaseRead()
-    }
-
-    suspend fun lockWrite(key: T) {
-        globalWritingLocker.withAcquire(globalWritingLocker.maxPermits) {
-            lockersWritingLocker.acquire()
-        }
-        try {
-            globalRWLocker.acquireRead()
-            try {
-                val locker = allocateLocker(key)
-                locker.lockWrite()
-            } catch (e: CancellationException) {
-                globalRWLocker.releaseRead()
-                throw e
-            }
-        } catch (e: CancellationException) {
-            lockersWritingLocker.release()
-            throw e
-        }
-    }
-    suspend fun unlockWrite(key: T): Boolean {
-        val locker = allocateLocker(key)
-        return (locker.unlockWrite() && globalRWLocker.releaseRead()).also {
-            if (it) {
-                lockersWritingLocker.release()
-            }
-        }
-    }
-    fun isWriteLocked(key: T): Boolean = lockers[key] ?.writeMutex ?.isLocked == true
-}
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquire(action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    acquireRead()
-    try {
-        return action()
-    } finally {
-        releaseRead()
-    }
-}
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLock(action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    lockWrite()
-    try {
-        return action()
-    } finally {
-        unlockWrite()
-    }
-}
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquire(key: T, action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    acquireRead(key)
-    try {
-        return action()
-    } finally {
-        releaseRead(key)
-    }
-}
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquires(keys: Iterable<T>, action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    val acquired = mutableSetOf<T>()
-    try {
-        keys.forEach {
-            acquireRead(it)
-            acquired.add(it)
-        }
-        return action()
-    } finally {
-        acquired.forEach {
-            releaseRead(it)
-        }
-    }
-}
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withReadAcquires(vararg keys: T, action: () -> R): R = withReadAcquires(keys.asIterable(), action)
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLock(key: T, action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    lockWrite(key)
-    try {
-        return action()
-    } finally {
-        unlockWrite(key)
-    }
-}
-
-@OptIn(ExperimentalContracts::class)
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLocks(keys: Iterable<T>, action: () -> R): R {
-    contract {
-        callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-    }
-
-    val locked = mutableSetOf<T>()
-    try {
-        keys.forEach {
-            lockWrite(it)
-            locked.add(it)
-        }
-        return action()
-    } finally {
-        locked.forEach {
-            unlockWrite(it)
-        }
-    }
-}
-
-suspend inline fun <T, R> SmartKeyRWLocker<T>.withWriteLocks(vararg keys: T, action: () -> R): R = withWriteLocks(keys.asIterable(), action)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/SmartRWLocker.kt

@@ -1,6 +1,5 @@
 package dev.inmo.micro_utils.coroutines
 
-import kotlinx.coroutines.CancellationException
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -8,10 +7,9 @@ import kotlin.contracts.contract
 /**
  * Composite mutex which works with next rules:
  *
- * * [acquireRead] require to [writeMutex] to be free. Then it will take one lock from [readSemaphore]
+ * * [acquireRead] require to [writeMutex] be free. Then it will take one lock from [readSemaphore]
  * * [releaseRead] will just free up one permit in [readSemaphore]
- * * [lockWrite] will lock [writeMutex] and then await while all [readSemaphore] will be freed. If coroutine will be
+ * * [lockWrite] will lock [writeMutex] and then await while all [readSemaphore] will be freed
- * cancelled during read semaphore freeing, locking will be cancelled too with [SmartMutex.Mutable.unlock]ing of [writeMutex]
  * * [unlockWrite] will just unlock [writeMutex]
  */
 class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked: Boolean = false) {
@@ -41,12 +39,7 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
      */
     suspend fun lockWrite() {
         _writeMutex.lock()
-        try {
+        _readSemaphore.acquire(readPermits)
-            _readSemaphore.acquire(readPermits)
-        } catch (e: CancellationException) {
-            _writeMutex.unlock()
-            throw e
-        }
     }
 
     /**

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/SmartRWLockerExtensions.kt

@@ -1,23 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-
-suspend inline fun alsoWithUnlockingOnSuccess(
-    vararg lockers: SmartRWLocker,
-    block: suspend () -> Unit
-): Result<Unit> {
-    return runCatching {
-        block()
-    }.onSuccess {
-        lockers.forEach { it.unlockWrite() }
-    }
-}
-
-fun alsoWithUnlockingOnSuccessAsync(
-    scope: CoroutineScope,
-    vararg lockers: SmartRWLocker,
-    block: suspend () -> Unit
-): Job = scope.launchLoggingDropExceptions {
-    alsoWithUnlockingOnSuccess(*lockers, block = block)
-}

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/SmartSemaphore.kt

@@ -24,7 +24,6 @@ import kotlin.contracts.contract
  * [Mutable] creator
  */
 sealed interface SmartSemaphore {
-    val maxPermits: Int
     val permitsStateFlow: StateFlow<Int>
 
     /**
@@ -37,7 +36,7 @@ sealed interface SmartSemaphore {
     /**
      * Immutable variant of [SmartSemaphore]. In fact will depend on the owner of [permitsStateFlow]
      */
-    class Immutable(override val permitsStateFlow: StateFlow<Int>, override val maxPermits: Int) : SmartSemaphore
+    class Immutable(override val permitsStateFlow: StateFlow<Int>) : SmartSemaphore
 
     /**
      * Mutable variant of [SmartSemaphore]. With that variant you may [lock] and [unlock]. Besides, you may create
@@ -45,16 +44,15 @@ sealed interface SmartSemaphore {
      *
      * @param locked Preset state of [freePermits] and its internal [_freePermitsStateFlow]
      */
-    class Mutable(permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
+    class Mutable(private val permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
-        override val maxPermits: Int = permits
         private val _freePermitsStateFlow = SpecialMutableStateFlow<Int>(permits - acquiredPermits)
         override val permitsStateFlow: StateFlow<Int> = _freePermitsStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex(false)
 
-        fun immutable() = Immutable(permitsStateFlow, maxPermits)
+        fun immutable() = Immutable(permitsStateFlow)
 
-        private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.maxPermits)
+        private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.permits)
 
         /**
          * Holds call until this [SmartSemaphore] will be re-locked. That means that current method will
@@ -128,10 +126,10 @@ sealed interface SmartSemaphore {
          */
         suspend fun release(permits: Int = 1): Boolean {
             val checkedPermits = checkedPermits(permits)
-            return if (_freePermitsStateFlow.value < this.maxPermits) {
+            return if (_freePermitsStateFlow.value < this.permits) {
                 internalChangesMutex.withLock {
-                    if (_freePermitsStateFlow.value < this.maxPermits) {
+                    if (_freePermitsStateFlow.value < this.permits) {
-                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, this.maxPermits)
+                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, this.permits)
                         true
                     } else {
                         false
@@ -168,4 +166,3 @@ suspend inline fun <T> SmartSemaphore.Mutable.withAcquire(permits: Int = 1, acti
  * the fact that some other parties may lock it again
  */
 suspend fun SmartSemaphore.waitRelease(permits: Int = 1) = permitsStateFlow.first { it >= permits }
-suspend fun SmartSemaphore.waitReleaseAll() = permitsStateFlow.first { it == maxPermits }

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/collections/SortedBinaryTreeNode.kt

@@ -1,318 +0,0 @@
-package dev.inmo.micro_utils.coroutines.collections
-
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import kotlinx.coroutines.job
-import kotlinx.serialization.Serializable
-import kotlin.coroutines.coroutineContext
-
-/**
- * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
- */
-private fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }
-
-@Serializable
-class SortedBinaryTreeNode<T>(
-    val data: T,
-    internal val comparator: Comparator<T>,
-) : Iterable<SortedBinaryTreeNode<T>> {
-    internal var leftNode: SortedBinaryTreeNode<T>? = null
-    internal var rightNode: SortedBinaryTreeNode<T>? = null
-    internal val locker: SmartRWLocker by lazy {
-        SmartRWLocker()
-    }
-
-    suspend fun getLeftNode() = locker.withReadAcquire {
-        leftNode
-    }
-
-    suspend fun getRightNode() = locker.withReadAcquire {
-        rightNode
-    }
-
-    suspend fun getLeft() = getLeftNode() ?.data
-
-    suspend fun getRight() = getRightNode() ?.data
-
-    override fun equals(other: Any?): Boolean {
-        return other === this || (other is SortedBinaryTreeNode<*> && other.data == data && other.rightNode == rightNode && other.leftNode == leftNode)
-    }
-
-    override fun hashCode(): Int {
-        return data.hashCode() * 31 + rightNode.hashCode() + leftNode.hashCode()
-    }
-
-    suspend fun size(): Int {
-        return locker.withReadAcquire {
-            1 + (leftNode ?.size() ?: 0) + (rightNode ?.size() ?: 0)
-        }
-    }
-
-    /**
-     * This [Iterator] will run from less to greater values of nodes starting the
-     * [dev.inmo.micro_utils.coroutines.collections.SortedBinaryTreeNode]-receiver. Due to non-suspending
-     * nature of [iterator] builder, this [Iterator] **DO NOT** guarantee consistent content due to iterations. It
-     * means, that tree can be changed during to iteration process
-     */
-    override fun iterator(): Iterator<SortedBinaryTreeNode<T>> = iterator {
-        leftNode ?.let {
-            it.iterator().forEach { yield(it) }
-        }
-        yield(this@SortedBinaryTreeNode)
-        rightNode ?.let {
-            it.iterator().forEach { yield(it) }
-        }
-    }
-
-    override fun toString(): String {
-        return "$data($leftNode;$rightNode)"
-    }
-
-    companion object {
-        operator fun <T : Comparable<T>> invoke(
-            data: T,
-        ) = SortedBinaryTreeNode(
-            data,
-            data.createComparator()
-        )
-    }
-}
-
-/**
- * Will add subnode in tree if there are no any node with [newData]
- *
- * * If [newData] is greater than [SortedBinaryTreeNode.data] of currently checking node,
- * will be used [SortedBinaryTreeNode.rightNode]
- * * If [newData] is equal to [SortedBinaryTreeNode.data] of currently
- * checking node - will be returned currently checking node
- * * If [newData] is less than [SortedBinaryTreeNode.data] of currently
- * checking node - will be used [SortedBinaryTreeNode.leftNode]
- *
- * This process will continue until function will not find place to put [SortedBinaryTreeNode] with data or
- * [SortedBinaryTreeNode] with [SortedBinaryTreeNode.data] same as [newData] will be found
- */
-private suspend fun <T> SortedBinaryTreeNode<T>.upsertSubNode(
-    subNode: SortedBinaryTreeNode<T>,
-    skipLockers: Set<SmartRWLocker> = emptySet()
-): SortedBinaryTreeNode<T> {
-    var currentlyChecking = this
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking.locker !in lockedLockers && currentlyChecking.locker !in skipLockers) {
-                currentlyChecking.locker.lockWrite()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val left = currentlyChecking.leftNode
-            val right = currentlyChecking.rightNode
-            val comparingResult = currentlyChecking.comparator.compare(subNode.data, currentlyChecking.data)
-            val isGreater = comparingResult > 0
-            when {
-                comparingResult == 0 -> return currentlyChecking
-                isGreater && right == null -> {
-                    currentlyChecking.rightNode = subNode
-                    return subNode
-                }
-                isGreater && right != null -> {
-                    currentlyChecking = right
-                }
-                left == null -> {
-                    currentlyChecking.leftNode = subNode
-                    return subNode
-                }
-                else -> {
-                    currentlyChecking = left
-                }
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.unlockWrite() }
-        }
-    }
-    error("Unable to add node")
-}
-
-/**
- * Will add subnode in tree if there are no any node with [newData]
- *
- * * If [newData] is greater than [SortedBinaryTreeNode.data] of currently checking node,
- * will be used [SortedBinaryTreeNode.rightNode]
- * * If [newData] is equal to [SortedBinaryTreeNode.data] of currently
- * checking node - will be returned currently checking node
- * * If [newData] is less than [SortedBinaryTreeNode.data] of currently
- * checking node - will be used [SortedBinaryTreeNode.leftNode]
- *
- * This process will continue until function will not find place to put [SortedBinaryTreeNode] with data or
- * [SortedBinaryTreeNode] with [SortedBinaryTreeNode.data] same as [newData] will be found
- */
-suspend fun <T> SortedBinaryTreeNode<T>.addSubNode(newData: T): SortedBinaryTreeNode<T> {
-    return upsertSubNode(
-        SortedBinaryTreeNode(newData, comparator)
-    )
-}
-
-suspend fun <T> SortedBinaryTreeNode<T>.findParentNode(data: T): SortedBinaryTreeNode<T>? {
-    var currentParent: SortedBinaryTreeNode<T>? = null
-    var currentlyChecking: SortedBinaryTreeNode<T>? = this
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking == null) {
-                return null
-            }
-            if (currentlyChecking.locker !in lockedLockers) {
-                currentlyChecking.locker.acquireRead()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.data)
-            when {
-                comparingResult > 0 -> {
-                    currentParent = currentlyChecking
-                    currentlyChecking = currentlyChecking.rightNode
-                    continue
-                }
-                comparingResult < 0 -> {
-                    currentParent = currentlyChecking
-                    currentlyChecking = currentlyChecking.leftNode
-                    continue
-                }
-                else -> return currentParent
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find node")
-}
-
-/**
- * Will remove (detach) node from tree starting with [this] [SortedBinaryTreeNode]
- *
- * @return If data were found, [Pair] where [Pair.first] is the parent node where from [Pair.second] has been detached;
- *         null otherwise
- */
-suspend fun <T> SortedBinaryTreeNode<T>.removeSubNode(data: T): Pair<SortedBinaryTreeNode<T>, SortedBinaryTreeNode<T>>? {
-    val onFoundToRemoveCallback: suspend SortedBinaryTreeNode<T>.(left: SortedBinaryTreeNode<T>?, right: SortedBinaryTreeNode<T>?) -> Unit = { left, right ->
-        left ?.also { leftNode -> upsertSubNode(leftNode, setOf(locker)) }
-        right ?.also { rightNode -> upsertSubNode(rightNode, setOf(locker)) }
-    }
-    while (coroutineContext.job.isActive) {
-        val foundParentNode = findParentNode(data) ?: return null
-        foundParentNode.locker.withWriteLock {
-            val left = foundParentNode.leftNode
-            val right = foundParentNode.rightNode
-            when {
-                left != null && left.comparator.compare(data, left.data) == 0 -> {
-                    foundParentNode.leftNode = null
-                    foundParentNode.onFoundToRemoveCallback(left.leftNode, left.rightNode)
-                    return foundParentNode to left
-                }
-                right != null && right.comparator.compare(data, right.data) == 0 -> {
-                    foundParentNode.rightNode = null
-                    foundParentNode.onFoundToRemoveCallback(right.leftNode, right.rightNode)
-                    return foundParentNode to right
-                }
-                else -> {
-                    return@withWriteLock // data has been changed, new search required
-                }
-            }
-        }
-    }
-    error("Unable to remove node")
-}
-suspend fun <T> SortedBinaryTreeNode<T>.findNode(data: T): SortedBinaryTreeNode<T>? {
-    var currentlyChecking: SortedBinaryTreeNode<T>? = this
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking == null) {
-                return null
-            }
-            if (currentlyChecking.locker !in lockedLockers) {
-                currentlyChecking.locker.acquireRead()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.data)
-            when {
-                comparingResult > 0 -> {
-                    currentlyChecking = currentlyChecking.rightNode
-                    continue
-                }
-                comparingResult < 0 -> {
-                    currentlyChecking = currentlyChecking.leftNode
-                    continue
-                }
-                else -> return currentlyChecking
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find node")
-}
-suspend fun <T> SortedBinaryTreeNode<T>.contains(data: T): Boolean = findNode(data) != null
-
-suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRange(from: T, to: T, fromInclusiveMode: Boolean, toInclusiveMode: Boolean): Set<SortedBinaryTreeNode<T>> {
-    val results = mutableSetOf<SortedBinaryTreeNode<T>>()
-    val leftToCheck = mutableSetOf(this)
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    val fromComparingFun: (SortedBinaryTreeNode<T>) -> Boolean = if (fromInclusiveMode) {
-        { it.comparator.compare(from, it.data) <= 0 }
-    } else {
-        { it.comparator.compare(from, it.data) < 0 }
-    }
-    val toComparingFun: (SortedBinaryTreeNode<T>) -> Boolean = if (toInclusiveMode) {
-        { it.comparator.compare(to, it.data) >= 0 }
-    } else {
-        { it.comparator.compare(to, it.data) > 0 }
-    }
-    try {
-        while (coroutineContext.job.isActive && leftToCheck.isNotEmpty()) {
-            val currentlyChecking = leftToCheck.first()
-            leftToCheck.remove(currentlyChecking)
-            if (currentlyChecking in results) {
-                continue
-            }
-            currentlyChecking.locker.acquireRead()
-            lockedLockers.add(currentlyChecking.locker)
-            if (fromComparingFun(currentlyChecking) && toComparingFun(currentlyChecking)) {
-                results.add(currentlyChecking)
-                currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
-                currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
-                continue
-            }
-            when {
-                currentlyChecking.comparator.compare(to, currentlyChecking.data) < 0 -> currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
-                currentlyChecking.comparator.compare(from, currentlyChecking.data) > 0 -> currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
-            }
-        }
-        return results.toSet()
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find nodes range")
-}
-suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRange(from: T, to: T): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
-    from = from,
-    to = to,
-    fromInclusiveMode = true,
-    toInclusiveMode = true
-)
-suspend fun <T> SortedBinaryTreeNode<T>.findNodesInRangeExcluding(from: T, to: T): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
-    from = from,
-    to = to,
-    fromInclusiveMode = false,
-    toInclusiveMode = false
-)
-suspend fun <T : Comparable<T>> SortedBinaryTreeNode<T>.findNodesInRange(range: ClosedRange<T>): Set<SortedBinaryTreeNode<T>> = findNodesInRange(
-    from = range.start,
-    to = range.endInclusive,
-)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/collections/SortedMapLikeBinaryTreeNode.kt

@@ -1,401 +0,0 @@
-package dev.inmo.micro_utils.coroutines.collections
-
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
-import kotlinx.coroutines.job
-import kotlinx.serialization.Serializable
-import kotlin.coroutines.coroutineContext
-
-/**
- * Creates simple [Comparator] which will use [compareTo] of [T] for both objects
- */
-private fun <T : Comparable<C>, C : T> T.createComparator() = Comparator<C> { o1, o2 -> o1.compareTo(o2) }
-
-@Serializable
-class SortedMapLikeBinaryTreeNode<K, V>(
-    val key: K,
-    val value: V,
-    internal val comparator: Comparator<K>,
-) : Iterable<SortedMapLikeBinaryTreeNode<K, V>> {
-    internal var leftNode: SortedMapLikeBinaryTreeNode<K, V>? = null
-    internal var rightNode: SortedMapLikeBinaryTreeNode<K, V>? = null
-    internal val locker: SmartRWLocker by lazy {
-        SmartRWLocker()
-    }
-
-    suspend fun getLeftNode() = locker.withReadAcquire {
-        leftNode
-    }
-
-    suspend fun getRightNode() = locker.withReadAcquire {
-        rightNode
-    }
-
-    suspend fun getLeftKey() = getLeftNode() ?.key
-    suspend fun getLeftValue() = getLeftNode() ?.value
-
-    suspend fun getRightKey() = getRightNode() ?.value
-    suspend fun getRightValue() = getRightNode() ?.value
-
-    override fun equals(other: Any?): Boolean {
-        return other === this || (other is SortedMapLikeBinaryTreeNode<*, *> && other.key == key && other.rightNode == rightNode && other.leftNode == leftNode)
-    }
-
-    override fun hashCode(): Int {
-        return key.hashCode() * 31 + rightNode.hashCode() + leftNode.hashCode()
-    }
-
-    suspend fun size(): Int {
-        return locker.withReadAcquire {
-            1 + (leftNode ?.size() ?: 0) + (rightNode ?.size() ?: 0)
-        }
-    }
-
-    /**
-     * This [Iterator] will run from less to greater values of nodes starting the
-     * [dev.inmo.micro_utils.coroutines.collections.SortedMapLikeBinaryTreeNode]-receiver. Due to non-suspending
-     * nature of [iterator] builder, this [Iterator] **DO NOT** guarantee consistent content due to iterations. It
-     * means, that tree can be changed during to iteration process
-     */
-    override fun iterator(): Iterator<SortedMapLikeBinaryTreeNode<K, V>> = iterator {
-        leftNode ?.let {
-            it.iterator().forEach { yield(it) }
-        }
-        yield(this@SortedMapLikeBinaryTreeNode)
-        rightNode ?.let {
-            it.iterator().forEach { yield(it) }
-        }
-    }
-
-    override fun toString(): String {
-        return "$key($leftNode;$rightNode)"
-    }
-
-    companion object {
-        operator fun <K : Comparable<K>, V> invoke(
-            key: K,
-            value: V
-        ) = SortedMapLikeBinaryTreeNode(
-            key,
-            value,
-            key.createComparator()
-        )
-    }
-}
-
-/**
- * Will add subnode in tree if there are no any node with [newData]
- *
- * * If [newData] is greater than [SortedMapLikeBinaryTreeNode.key] of currently checking node,
- * will be used [SortedMapLikeBinaryTreeNode.rightNode]
- * * If [newData] is equal to [SortedMapLikeBinaryTreeNode.key] of currently
- * checking node - will be returned currently checking node
- * * If [newData] is less than [SortedMapLikeBinaryTreeNode.key] of currently
- * checking node - will be used [SortedMapLikeBinaryTreeNode.leftNode]
- *
- * This process will continue until function will not find place to put [SortedMapLikeBinaryTreeNode] with data or
- * [SortedMapLikeBinaryTreeNode] with [SortedMapLikeBinaryTreeNode.key] same as [newData] will be found
- *
- * @param replaceMode Will replace only value if node already exists
- */
-private suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.upsertSubNode(
-    subNode: SortedMapLikeBinaryTreeNode<K, V>,
-    skipLockers: Set<SmartRWLocker> = emptySet(),
-    replaceMode: Boolean
-): SortedMapLikeBinaryTreeNode<K, V> {
-    var currentlyChecking = this
-    var latestParent: SortedMapLikeBinaryTreeNode<K, V>? = null
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking.locker !in lockedLockers && currentlyChecking.locker !in skipLockers) {
-                currentlyChecking.locker.lockWrite()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val left = currentlyChecking.leftNode
-            val right = currentlyChecking.rightNode
-            val comparingResult = currentlyChecking.comparator.compare(subNode.key, currentlyChecking.key)
-            val isGreater = comparingResult > 0
-            when {
-                comparingResult == 0 -> {
-                    val resultNode = if (replaceMode) {
-                        subNode
-                    } else {
-                        val newNode = SortedMapLikeBinaryTreeNode(
-                            subNode.key,
-                            subNode.value,
-                            currentlyChecking.comparator,
-                        )
-                        newNode.leftNode = currentlyChecking.leftNode
-                        newNode.rightNode = currentlyChecking.rightNode
-                        newNode
-                    }
-
-                    latestParent ?.let {
-                        when {
-                            it.leftNode === currentlyChecking -> it.leftNode = resultNode
-                            it.rightNode === currentlyChecking -> it.rightNode = resultNode
-                        }
-                    }
-
-                    return resultNode
-                }
-                isGreater && right == null -> {
-                    currentlyChecking.rightNode = subNode
-                    return subNode
-                }
-                isGreater && right != null -> {
-                    latestParent = currentlyChecking
-                    currentlyChecking = right
-                }
-                left == null -> {
-                    currentlyChecking.leftNode = subNode
-                    return subNode
-                }
-                else -> {
-                    latestParent = currentlyChecking
-                    currentlyChecking = left
-                }
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.unlockWrite() }
-        }
-    }
-    error("Unable to add node")
-}
-
-/**
- * Will add subnode in tree if there are no any node with [key]
- *
- * * If [key] is greater than [SortedMapLikeBinaryTreeNode.key] of currently checking node,
- * will be used [SortedMapLikeBinaryTreeNode.rightNode]
- * * If [key] is equal to [SortedMapLikeBinaryTreeNode.key] of currently
- * checking node - will be returned currently checking node
- * * If [key] is less than [SortedMapLikeBinaryTreeNode.key] of currently
- * checking node - will be used [SortedMapLikeBinaryTreeNode.leftNode]
- *
- * This process will continue until function will not find place to put [SortedMapLikeBinaryTreeNode] with data or
- * [SortedMapLikeBinaryTreeNode] with [SortedMapLikeBinaryTreeNode.key] same as [key] will be found
- */
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.upsertSubNode(
-    key: K,
-    value: V
-): SortedMapLikeBinaryTreeNode<K, V> {
-    return upsertSubNode(
-        SortedMapLikeBinaryTreeNode(key, value, comparator),
-        replaceMode = false
-    )
-}
-
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findParentNode(data: K): SortedMapLikeBinaryTreeNode<K, V>? {
-    var currentParent: SortedMapLikeBinaryTreeNode<K, V>? = null
-    var currentlyChecking: SortedMapLikeBinaryTreeNode<K, V>? = this
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking == null) {
-                return null
-            }
-            if (currentlyChecking.locker !in lockedLockers) {
-                currentlyChecking.locker.acquireRead()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val comparingResult = currentlyChecking.comparator.compare(data, currentlyChecking.key)
-            when {
-                comparingResult > 0 -> {
-                    currentParent = currentlyChecking
-                    currentlyChecking = currentlyChecking.rightNode
-                    continue
-                }
-                comparingResult < 0 -> {
-                    currentParent = currentlyChecking
-                    currentlyChecking = currentlyChecking.leftNode
-                    continue
-                }
-                else -> return currentParent
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find node")
-}
-
-/**
- * Will remove (detach) node from tree starting with [this] [SortedMapLikeBinaryTreeNode]
- *
- * @return If data were found, [Pair] where [Pair.first] is the parent node where from [Pair.second] has been detached;
- *         null otherwise
- */
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.removeSubNode(data: K): Pair<SortedMapLikeBinaryTreeNode<K, V>, SortedMapLikeBinaryTreeNode<K, V>>? {
-    val onFoundToRemoveCallback: suspend SortedMapLikeBinaryTreeNode<K, V>.(left: SortedMapLikeBinaryTreeNode<K, V>?, right: SortedMapLikeBinaryTreeNode<K, V>?) -> Unit = { left, right ->
-        left ?.also { leftNode -> upsertSubNode(leftNode, setOf(locker), replaceMode = true) }
-        right ?.also { rightNode -> upsertSubNode(rightNode, setOf(locker), replaceMode = true) }
-    }
-    while (coroutineContext.job.isActive) {
-        val foundParentNode = findParentNode(data) ?: return null
-        foundParentNode.locker.withWriteLock {
-            val left = foundParentNode.leftNode
-            val right = foundParentNode.rightNode
-            when {
-                left != null && left.comparator.compare(data, left.key) == 0 -> {
-                    foundParentNode.leftNode = null
-                    foundParentNode.onFoundToRemoveCallback(left.leftNode, left.rightNode)
-                    return foundParentNode to left
-                }
-                right != null && right.comparator.compare(data, right.key) == 0 -> {
-                    foundParentNode.rightNode = null
-                    foundParentNode.onFoundToRemoveCallback(right.leftNode, right.rightNode)
-                    return foundParentNode to right
-                }
-                else -> {
-                    return@withWriteLock // data has been changed, new search required
-                }
-            }
-        }
-    }
-    error("Unable to remove node")
-}
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNode(key: K): SortedMapLikeBinaryTreeNode<K, V>? {
-    var currentlyChecking: SortedMapLikeBinaryTreeNode<K, V>? = this
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (coroutineContext.job.isActive) {
-            if (currentlyChecking == null) {
-                return null
-            }
-            if (currentlyChecking.locker !in lockedLockers) {
-                currentlyChecking.locker.acquireRead()
-                lockedLockers.add(currentlyChecking.locker)
-            }
-            val comparingResult = currentlyChecking.comparator.compare(key, currentlyChecking.key)
-            when {
-                comparingResult > 0 -> {
-                    currentlyChecking = currentlyChecking.rightNode
-                    continue
-                }
-                comparingResult < 0 -> {
-                    currentlyChecking = currentlyChecking.leftNode
-                    continue
-                }
-                else -> return currentlyChecking
-            }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find node")
-}
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.contains(data: K): Boolean = findNode(data) != null
-
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(from: K, to: K, fromInclusiveMode: Boolean, toInclusiveMode: Boolean): Set<SortedMapLikeBinaryTreeNode<K, V>> {
-    val results = mutableSetOf<SortedMapLikeBinaryTreeNode<K, V>>()
-    val leftToCheck = mutableSetOf(this)
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    val fromComparingFun: (SortedMapLikeBinaryTreeNode<K, V>) -> Boolean = if (fromInclusiveMode) {
-        { it.comparator.compare(from, it.key) <= 0 }
-    } else {
-        { it.comparator.compare(from, it.key) < 0 }
-    }
-    val toComparingFun: (SortedMapLikeBinaryTreeNode<K, V>) -> Boolean = if (toInclusiveMode) {
-        { it.comparator.compare(to, it.key) >= 0 }
-    } else {
-        { it.comparator.compare(to, it.key) > 0 }
-    }
-    try {
-        while (coroutineContext.job.isActive && leftToCheck.isNotEmpty()) {
-            val currentlyChecking = leftToCheck.first()
-            leftToCheck.remove(currentlyChecking)
-            if (currentlyChecking in results) {
-                continue
-            }
-            currentlyChecking.locker.acquireRead()
-            lockedLockers.add(currentlyChecking.locker)
-            if (fromComparingFun(currentlyChecking) && toComparingFun(currentlyChecking)) {
-                results.add(currentlyChecking)
-                currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
-                currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
-                continue
-            }
-            when {
-                currentlyChecking.comparator.compare(to, currentlyChecking.key) < 0 -> currentlyChecking.leftNode ?.let { leftToCheck.add(it) }
-                currentlyChecking.comparator.compare(from, currentlyChecking.key) > 0 -> currentlyChecking.rightNode ?.let { leftToCheck.add(it) }
-            }
-        }
-        return results.toSet()
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-    error("Unable to find nodes range")
-}
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.deepEquals(other: SortedMapLikeBinaryTreeNode<K, V>): Boolean {
-    val leftToCheck = mutableSetOf(this)
-    val othersToCheck = mutableSetOf(other)
-    val lockedLockers = mutableSetOf<SmartRWLocker>()
-    try {
-        while (leftToCheck.isNotEmpty() && othersToCheck.isNotEmpty()) {
-            val thisToCheck = leftToCheck.first()
-            leftToCheck.remove(thisToCheck)
-
-            val otherToCheck = othersToCheck.first()
-            othersToCheck.remove(otherToCheck)
-
-            if (thisToCheck.locker !in lockedLockers) {
-                thisToCheck.locker.acquireRead()
-                lockedLockers.add(thisToCheck.locker)
-            }
-            if (otherToCheck.locker !in lockedLockers) {
-                otherToCheck.locker.acquireRead()
-                lockedLockers.add(otherToCheck.locker)
-            }
-
-            if (thisToCheck.key != otherToCheck.key || thisToCheck.value != otherToCheck.value) {
-                return false
-            }
-
-            if ((thisToCheck.leftNode == null).xor(otherToCheck.leftNode == null)) {
-                return false
-            }
-            if ((thisToCheck.rightNode == null).xor(otherToCheck.rightNode == null)) {
-                return false
-            }
-
-            thisToCheck.leftNode?.let { leftToCheck.add(it) }
-            thisToCheck.rightNode?.let { leftToCheck.add(it) }
-
-            otherToCheck.leftNode?.let { othersToCheck.add(it) }
-            otherToCheck.rightNode?.let { othersToCheck.add(it) }
-        }
-    } finally {
-        lockedLockers.forEach {
-            runCatching { it.releaseRead() }
-        }
-    }
-
-    return leftToCheck.isEmpty() && othersToCheck.isEmpty()
-}
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(from: K, to: K): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
-    from = from,
-    to = to,
-    fromInclusiveMode = true,
-    toInclusiveMode = true
-)
-suspend fun <K, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRangeExcluding(from: K, to: K): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
-    from = from,
-    to = to,
-    fromInclusiveMode = false,
-    toInclusiveMode = false
-)
-suspend fun <K : Comparable<K>, V> SortedMapLikeBinaryTreeNode<K, V>.findNodesInRange(range: ClosedRange<K>): Set<SortedMapLikeBinaryTreeNode<K, V>> = findNodesInRange(
-    from = range.start,
-    to = range.endInclusive,
-)

coroutines/src/commonTest/kotlin/RealTimeOut.kt

@@ -1,12 +0,0 @@
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeout
-import kotlin.time.Duration
-
-suspend fun <T> realWithTimeout(time: Duration, block: suspend () -> T): T {
-    return withContext(Dispatchers.Default.limitedParallelism(1)) {
-        withTimeout(time) {
-            block()
-        }
-    }
-}

coroutines/src/commonTest/kotlin/SmartKeyRWLockerTests.kt

@@ -1,196 +0,0 @@
-import dev.inmo.micro_utils.coroutines.*
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.test.runTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFails
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-
-class SmartKeyRWLockerTests {
-    @Test
-    fun writeLockKeyFailedOnGlobalWriteLockTest() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-        val testKey = "test"
-        locker.lockWrite()
-
-        assertTrue { locker.isWriteLocked() }
-
-        assertFails {
-            realWithTimeout(1.seconds) {
-                locker.lockWrite(testKey)
-            }
-        }
-        assertFalse { locker.isWriteLocked(testKey) }
-
-        locker.unlockWrite()
-        assertFalse { locker.isWriteLocked() }
-
-        realWithTimeout(1.seconds) {
-            locker.lockWrite(testKey)
-        }
-        assertTrue { locker.isWriteLocked(testKey) }
-        assertTrue { locker.unlockWrite(testKey) }
-        assertFalse { locker.isWriteLocked(testKey) }
-    }
-    @Test
-    fun writeLockKeyFailedOnGlobalReadLockTest() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-        val testKey = "test"
-        locker.acquireRead()
-
-        assertEquals(Int.MAX_VALUE - 1, locker.readSemaphore().freePermits)
-
-        assertFails {
-            realWithTimeout(1.seconds) {
-                locker.lockWrite(testKey)
-            }
-        }
-        assertFalse { locker.isWriteLocked(testKey) }
-
-        locker.releaseRead()
-        assertEquals(Int.MAX_VALUE, locker.readSemaphore().freePermits)
-
-        realWithTimeout(1.seconds) {
-            locker.lockWrite(testKey)
-        }
-        assertTrue { locker.isWriteLocked(testKey) }
-        assertTrue { locker.unlockWrite(testKey) }
-        assertFalse { locker.isWriteLocked(testKey) }
-    }
-    @Test
-    fun readLockFailedOnWriteLockKeyTest() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-        val testKey = "test"
-        locker.lockWrite(testKey)
-
-        assertTrue { locker.isWriteLocked(testKey) }
-
-        assertFails {
-            realWithTimeout(1.seconds) {
-                locker.acquireRead()
-            }
-        }
-        assertEquals(locker.readSemaphore().maxPermits - 1, locker.readSemaphore().freePermits)
-
-        locker.unlockWrite(testKey)
-        assertFalse { locker.isWriteLocked(testKey) }
-
-        realWithTimeout(1.seconds) {
-            locker.acquireRead()
-        }
-        assertEquals(locker.readSemaphore().maxPermits - 1, locker.readSemaphore().freePermits)
-        assertTrue { locker.releaseRead() }
-        assertEquals(locker.readSemaphore().maxPermits, locker.readSemaphore().freePermits)
-    }
-    @Test
-    fun writeLockFailedOnWriteLockKeyTest() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-        val testKey = "test"
-        locker.lockWrite(testKey)
-
-        assertTrue { locker.isWriteLocked(testKey) }
-
-        assertFails {
-            realWithTimeout(1.seconds) {
-                locker.lockWrite()
-            }
-        }
-        assertFalse(locker.isWriteLocked())
-
-        locker.unlockWrite(testKey)
-        assertFalse { locker.isWriteLocked(testKey) }
-
-        realWithTimeout(1.seconds) {
-            locker.lockWrite()
-        }
-        assertTrue(locker.isWriteLocked())
-        assertTrue { locker.unlockWrite() }
-        assertFalse(locker.isWriteLocked())
-    }
-    @Test
-    fun readsBlockingGlobalWrite() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-
-        val testKeys = (0 until 100).map { "test$it" }
-
-        for (i in testKeys.indices) {
-            val it = testKeys[i]
-            locker.acquireRead(it)
-            val previous = testKeys.take(i)
-            val next = testKeys.drop(i + 1)
-
-            previous.forEach {
-                assertTrue { locker.readSemaphoreOrNull(it) ?.freePermits == Int.MAX_VALUE - 1 }
-            }
-            next.forEach {
-                assertTrue { locker.readSemaphoreOrNull(it) ?.freePermits == null }
-            }
-        }
-
-        for (i in testKeys.indices) {
-            val it = testKeys[i]
-            assertFails {
-                realWithTimeout(13.milliseconds) { locker.lockWrite() }
-            }
-            val readPermitsBeforeLock = locker.readSemaphore().freePermits
-            realWithTimeout(1.seconds) { locker.acquireRead() }
-            locker.releaseRead()
-            assertEquals(readPermitsBeforeLock, locker.readSemaphore().freePermits)
-
-            locker.releaseRead(it)
-        }
-
-        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
-        realWithTimeout(1.seconds) { locker.lockWrite() }
-        assertFails {
-            realWithTimeout(13.milliseconds) { locker.acquireRead() }
-        }
-        assertTrue { locker.unlockWrite() }
-        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
-    }
-    @Test
-    fun writesBlockingGlobalWrite() = runTest {
-        val locker = SmartKeyRWLocker<String>()
-
-        val testKeys = (0 until 100).map { "test$it" }
-
-        for (i in testKeys.indices) {
-            val it = testKeys[i]
-            locker.lockWrite(it)
-            val previous = testKeys.take(i)
-            val next = testKeys.drop(i + 1)
-
-            previous.forEach {
-                assertTrue { locker.writeMutexOrNull(it) ?.isLocked == true }
-            }
-            next.forEach {
-                assertTrue { locker.writeMutexOrNull(it) ?.isLocked != true }
-            }
-        }
-
-        for (i in testKeys.indices) {
-            val it = testKeys[i]
-            assertFails { realWithTimeout(13.milliseconds) { locker.lockWrite() } }
-
-            val readPermitsBeforeLock = locker.readSemaphore().freePermits
-            assertFails { realWithTimeout(13.milliseconds) { locker.acquireRead() } }
-            assertEquals(readPermitsBeforeLock, locker.readSemaphore().freePermits)
-
-            locker.unlockWrite(it)
-        }
-
-        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
-        realWithTimeout(1.seconds) { locker.lockWrite() }
-        assertFails {
-            realWithTimeout(13.milliseconds) { locker.acquireRead() }
-        }
-        assertTrue { locker.unlockWrite() }
-        assertTrue { locker.readSemaphore().freePermits == Int.MAX_VALUE }
-    }
-}

coroutines/src/commonTest/kotlin/SmartRWLockerTests.kt

@@ -6,10 +6,7 @@ import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertFails
-import kotlin.test.assertFalse
 import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.seconds
 
 class SmartRWLockerTests {
     @Test
@@ -151,17 +148,4 @@ class SmartRWLockerTests {
             assertEquals(false, locker.writeMutex.isLocked)
         }
     }
-
-    @Test
-    fun exceptionOnLockingWillNotLockLocker() = runTest {
-        val locker = SmartRWLocker()
-
-        locker.acquireRead()
-        assertFails {
-            realWithTimeout(1.seconds) {
-                locker.lockWrite()
-            }
-        }
-        assertFalse { locker.writeMutex.isLocked }
-    }
 }

coroutines/src/jvmMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSynchronously.kt

@@ -7,9 +7,7 @@ fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T
     val objectToSynchronize = Object()
     synchronized(objectToSynchronize) {
         launch(start = CoroutineStart.UNDISPATCHED) {
-            result = runCatching {
+            result = safelyWithResult(block)
-                block()
-            }
         }.invokeOnCompletion {
             synchronized(objectToSynchronize) {
                 objectToSynchronize.notifyAll()

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/HandleSafelyCoroutineContextTest.kt

@@ -1,20 +1,25 @@
 package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.*
-import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 
 class HandleSafelyCoroutineContextTest {
     @Test
-    fun testHandleSafelyCoroutineContext() = runTest {
+    fun testHandleSafelyCoroutineContext() {
-        val scope = this
+        val scope = CoroutineScope(Dispatchers.Default)
         var contextHandlerHappen = false
         var localHandlerHappen = false
+        var defaultHandlerHappen = false
+        defaultSafelyExceptionHandler = {
+            defaultHandlerHappen = true
+            throw it
+        }
+        val contextHandler: ExceptionHandler<Unit> = {
+            contextHandlerHappen = true
+        }
         val checkJob = scope.launch {
-            runCatchingLogging ({
+            safelyWithContextExceptionHandler(contextHandler) {
-                contextHandlerHappen = true
+                safely(
-            }) {
-                runCatchingLogging (
                     {
                         localHandlerHappen = true
                     }
@@ -24,8 +29,10 @@ class HandleSafelyCoroutineContextTest {
                 println(coroutineContext)
                 error("That must happen too:)")
             }
-        }.join()
+        }
+        launchSynchronously { checkJob.join() }
         assert(contextHandlerHappen)
         assert(localHandlerHappen)
+        assert(defaultHandlerHappen)
     }
 }

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/SortedBinaryTreeNodeTests.kt

@@ -1,176 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import dev.inmo.micro_utils.coroutines.collections.SortedBinaryTreeNode
-import dev.inmo.micro_utils.coroutines.collections.addSubNode
-import dev.inmo.micro_utils.coroutines.collections.findNode
-import dev.inmo.micro_utils.coroutines.collections.findNodesInRange
-import dev.inmo.micro_utils.coroutines.collections.findParentNode
-import dev.inmo.micro_utils.coroutines.collections.removeSubNode
-import kotlinx.coroutines.test.runTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.seconds
-
-class SortedBinaryTreeNodeTests {
-    @Test
-    fun insertOnZeroLevelWorks() = runTest {
-        val zeroNode = SortedBinaryTreeNode(0)
-        zeroNode.addSubNode(1)
-        zeroNode.addSubNode(-1)
-
-        assertEquals(0, zeroNode.data)
-        assertEquals(1, zeroNode.getRightNode() ?.data)
-        assertEquals(-1, zeroNode.getLeftNode() ?.data)
-    }
-    @Test
-    fun searchOnZeroLevelWorks() = runTest {
-        val zeroNode = SortedBinaryTreeNode(0)
-        val oneNode = zeroNode.addSubNode(1)
-        val minusOneNode = zeroNode.addSubNode(-1)
-
-        val assertingNodesToSearchQuery = mapOf(
-            setOf(oneNode) to (1 .. 1),
-            setOf(zeroNode, oneNode) to (0 .. 1),
-            setOf(minusOneNode, zeroNode, oneNode) to (-1 .. 1),
-            setOf(minusOneNode, zeroNode) to (-1 .. 0),
-            setOf(minusOneNode) to (-1 .. -1),
-            setOf(zeroNode) to (0 .. 0),
-        )
-
-        assertingNodesToSearchQuery.forEach {
-            val foundData = zeroNode.findNodesInRange(it.value)
-            assertTrue(foundData.containsAll(it.key))
-            assertTrue(it.key.containsAll(foundData))
-        }
-    }
-    @Test
-    fun deepReInsertOnWorks() = runTest(timeout = 300.seconds) {
-        val zeroNode = SortedBinaryTreeNode(0)
-        val rangeRadius = 500
-        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
-        for (i in -rangeRadius .. rangeRadius) {
-            nodes[i] = zeroNode.addSubNode(i)
-        }
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val foundNode = zeroNode.findNode(i)
-
-            assertTrue(expectedNode === foundNode)
-
-            if (expectedNode === zeroNode) continue
-
-            val parentNode = zeroNode.findParentNode(i)
-            assertTrue(
-                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
-            )
-        }
-
-        val sourceTreeSize = zeroNode.size()
-        assertTrue(sourceTreeSize == nodes.size)
-        assertTrue(sourceTreeSize == (rangeRadius * 2 + 1))
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val parentNode = zeroNode.findParentNode(i)
-
-            if (parentNode == null && i == zeroNode.data && expectedNode === zeroNode) continue
-
-            assertTrue(parentNode != null, "It is expected, that parent node of ${expectedNode.data} will not be null")
-
-            assertTrue(
-                parentNode.getLeftNode() === expectedNode || parentNode.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
-            )
-
-            val removeResult = zeroNode.removeSubNode(i)
-            assertTrue(removeResult ?.first === parentNode)
-            assertTrue(removeResult.second === expectedNode)
-
-            nodes[i] = zeroNode.addSubNode(i)
-            assertTrue(nodes[i] != null)
-            assertTrue(nodes[i] != expectedNode)
-            assertTrue(nodes[i] ?.data == i)
-        }
-
-        assertTrue(sourceTreeSize == zeroNode.size())
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val foundNode = zeroNode.findNode(i)
-
-            assertTrue(expectedNode === foundNode)
-
-            if (expectedNode === zeroNode) continue
-
-            val parentNode = zeroNode.findParentNode(i)
-            assertTrue(
-                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
-            )
-        }
-
-        var previousData = -rangeRadius - 1
-        for (node in zeroNode) {
-            assertTrue(nodes[node.data] === node)
-            assertTrue(previousData == node.data - 1)
-            previousData = node.data
-        }
-
-        assertTrue(sourceTreeSize == zeroNode.size())
-    }
-    @Test
-    fun deepInsertOnWorks() = runTest(timeout = 240.seconds) {
-        val zeroNode = SortedBinaryTreeNode(0)
-        val rangeRadius = 500
-        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
-        for (i in -rangeRadius .. rangeRadius) {
-            nodes[i] = zeroNode.addSubNode(i)
-        }
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val foundNode = zeroNode.findNode(i)
-
-            assertTrue(expectedNode === foundNode)
-
-            if (expectedNode === zeroNode) continue
-
-            val parentNode = zeroNode.findParentNode(i)
-            assertTrue(
-                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.data} will be parent of ${expectedNode.data}, but its left subnode is ${parentNode ?.getLeftNode() ?.data} and right one is ${parentNode ?.getRightNode() ?.data}"
-            )
-        }
-
-        val sourceTreeSize = zeroNode.size()
-
-        var previousData = -rangeRadius - 1
-        for (node in zeroNode) {
-            assertTrue(nodes[node.data] === node)
-            assertTrue(previousData == node.data - 1)
-            previousData = node.data
-        }
-
-        assertTrue(sourceTreeSize == zeroNode.size())
-    }
-    @Test
-    fun deepInsertIteratorWorking() = runTest {
-        val zeroNode = SortedBinaryTreeNode(0)
-        val rangeRadius = 500
-        val nodes = mutableMapOf<Int, SortedBinaryTreeNode<Int>>()
-        for (i in -rangeRadius .. rangeRadius) {
-            nodes[i] = zeroNode.addSubNode(i)
-        }
-
-        var previousData = -rangeRadius - 1
-        for (node in zeroNode) {
-            assertTrue(nodes[node.data] === node)
-            assertTrue(previousData == node.data - 1)
-            previousData = node.data
-        }
-        assertTrue(previousData == rangeRadius)
-    }
-}

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/SortedMapLikeBinaryTreeNodeTests.kt

@@ -1,118 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import dev.inmo.micro_utils.coroutines.collections.*
-import kotlinx.coroutines.test.runTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.seconds
-
-class SortedMapLikeBinaryTreeNodeTests {
-    @Test
-    fun insertOnZeroLevelWorks() = runTest {
-        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
-        zeroNode.upsertSubNode(1, 1)
-        zeroNode.upsertSubNode(-1, -1)
-
-        assertEquals(0, zeroNode.key)
-        assertEquals(1, zeroNode.getRightNode() ?.key)
-        assertEquals(-1, zeroNode.getLeftNode() ?.key)
-
-        assertEquals(0, zeroNode.findNode(0) ?.value)
-        assertEquals(1, zeroNode.findNode(1) ?.value)
-        assertEquals(-1, zeroNode.findNode(-1) ?.value)
-    }
-    @Test
-    fun searchOnZeroLevelWorks() = runTest {
-        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
-        val oneNode = zeroNode.upsertSubNode(1, 1)
-        val minusOneNode = zeroNode.upsertSubNode(-1, -1)
-
-        val assertingNodesToSearchQuery = mapOf(
-            setOf(oneNode) to (1 .. 1),
-            setOf(zeroNode, oneNode) to (0 .. 1),
-            setOf(minusOneNode, zeroNode, oneNode) to (-1 .. 1),
-            setOf(minusOneNode, zeroNode) to (-1 .. 0),
-            setOf(minusOneNode) to (-1 .. -1),
-            setOf(zeroNode) to (0 .. 0),
-        )
-
-        assertingNodesToSearchQuery.forEach {
-            val foundData = zeroNode.findNodesInRange(it.value)
-            assertTrue(foundData.containsAll(it.key))
-            assertTrue(it.key.containsAll(foundData))
-        }
-    }
-    @Test
-    fun deepReInsertOnWorks() = runTest(timeout = 300.seconds) {
-        var zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
-        val rangeRadius = 500
-        val nodes = mutableMapOf<Int, SortedMapLikeBinaryTreeNode<Int, Int>>()
-        for (i in -rangeRadius .. rangeRadius) {
-            nodes[i] = zeroNode.upsertSubNode(i, i)
-            if (i == zeroNode.key) {
-                zeroNode = nodes.getValue(i)
-            }
-        }
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val foundNode = zeroNode.findNode(i)
-
-            assertEquals(expectedNode, foundNode)
-
-            if (expectedNode === zeroNode) continue
-
-            val parentNode = zeroNode.findParentNode(i)
-            assertTrue(
-                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.key} will be parent of ${expectedNode.key}, but its left subnode is ${parentNode ?.getLeftNode() ?.key} and right one is ${parentNode ?.getRightNode() ?.key}"
-            )
-            assertTrue(
-                foundNode != null && expectedNode.deepEquals(foundNode)
-            )
-
-            zeroNode.upsertSubNode(i, -i)
-            val foundModifiedNode = zeroNode.findNode(i)
-            assertEquals(foundNode ?.value, foundModifiedNode ?.value ?.times(-1))
-        }
-    }
-    @Test
-    fun deepInsertOnWorks() = runTest(timeout = 240.seconds) {
-        val zeroNode = SortedMapLikeBinaryTreeNode(0, 0)
-        val rangeRadius = 500
-        val nodes = mutableMapOf<Int, SortedMapLikeBinaryTreeNode<Int, Int>>()
-        for (i in -rangeRadius .. rangeRadius) {
-            if (zeroNode.key != i) {
-                nodes[i] = zeroNode.upsertSubNode(i, i)
-            }
-        }
-        nodes[zeroNode.key] = zeroNode
-
-        for (i in -rangeRadius .. rangeRadius) {
-            val expectedNode = nodes.getValue(i)
-            val foundNode = zeroNode.findNode(i)
-
-            assertTrue(expectedNode === foundNode)
-
-            if (expectedNode === zeroNode) continue
-
-            val parentNode = zeroNode.findParentNode(i)
-            assertTrue(
-                parentNode ?.getLeftNode() === expectedNode || parentNode ?.getRightNode() === expectedNode,
-                "It is expected, that parent node with data ${parentNode ?.key} will be parent of ${expectedNode.key}, but its left subnode is ${parentNode ?.getLeftNode() ?.key} and right one is ${parentNode ?.getRightNode() ?.key}"
-            )
-        }
-
-        val sourceTreeSize = zeroNode.size()
-
-        var previousData = -rangeRadius - 1
-        for (node in zeroNode) {
-            assertTrue(nodes[node.key] === node)
-            assertTrue(previousData == node.key - 1)
-            previousData = node.key
-        }
-
-        assertTrue(sourceTreeSize == zeroNode.size())
-    }
-}

crypto/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {

extensions.gradle

@@ -30,13 +30,3 @@ allprojects {
         }
     }
 }
-
-tasks.register("getPublishableModules") {
-    doLast {
-        rootProject.subprojects.each { project ->
-            if (project.plugins.hasPlugin('maven-publish')) {
-                println(":${project.name}")
-            }
-        }
-    }
-}

fsm/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {
@@ -12,7 +12,6 @@ kotlin {
             dependencies {
                 api project(":micro_utils.common")
                 api project(":micro_utils.coroutines")
-                api libs.kslog
             }
         }
     }

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/StatesMachine.kt

@@ -1,7 +1,5 @@
 package dev.inmo.micro_utils.fsm.common
 
-import dev.inmo.kslog.common.TagLogger
-import dev.inmo.kslog.common.e
 import dev.inmo.micro_utils.common.Optional
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
@@ -70,7 +68,6 @@ open class DefaultStatesMachine <T: State>(
     protected val handlers: List<CheckableHandlerHolder<in T, T>>,
     protected val onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler()
 ) : StatesMachine<T> {
-    protected val logger = TagLogger(this::class.simpleName!!)
     /**
      * Will call [launchStateHandling] for state handling
      */
@@ -99,13 +96,7 @@ open class DefaultStatesMachine <T: State>(
         statesJobsMutex.withLock {
             statesJobs[actualState] ?.cancel()
             statesJobs[actualState] = scope.launch {
-                runCatching {
+                performUpdate(actualState)
-                    performUpdate(actualState)
-                }.onFailure {
-                    logger.e(it) {
-                        "Unable to perform update of state from $actualState"
-                    }
-                }.getOrThrow()
             }.also { job ->
                 job.invokeOnCompletion { _ ->
                     scope.launch {
@@ -128,10 +119,8 @@ open class DefaultStatesMachine <T: State>(
      */
     override fun start(scope: CoroutineScope): Job {
         val supervisorScope = scope.LinkedSupervisorScope()
-        supervisorScope.launchLoggingDropExceptions {
+        supervisorScope.launchSafelyWithoutExceptions {
-            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(
+            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(supervisorScope) {
-                supervisorScope
-            ) {
                 supervisorScope.launch { performStateUpdate(Optional.absent(), it, supervisorScope) }
             }
             statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(supervisorScope) {
@@ -142,7 +131,7 @@ open class DefaultStatesMachine <T: State>(
                     statesJobsMutex.withLock {
                         val stateInMap = statesJobs.keys.firstOrNull { stateInMap -> stateInMap == removedState }
                         if (stateInMap === removedState) {
-                            statesJobs[stateInMap]?.cancel()
+                            statesJobs[stateInMap] ?.cancel()
                         }
                     }
                 }

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/StatesManager.kt

@@ -9,12 +9,7 @@ interface StatesManager<T : State> {
 
 
     /**
-     * It is expected, that [new] state will be saved in manager.
+     * Must set current set using [State.context]
-     *
-     * If [new] context will not be equal to [old] one, it must do some check of availability for replacement
-     * of potentially exists state on [new] context. If this state can't be replaced, it will throw [IllegalStateException]
-     *
-     * @throws IllegalStateException - in case when [new] [State] can't be set
      */
     suspend fun update(old: T, new: T)
 

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/UpdatableStatesMachine.kt

@@ -1,6 +1,5 @@
 package dev.inmo.micro_utils.fsm.common
 
-import dev.inmo.kslog.common.e
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
 import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
@@ -45,13 +44,7 @@ open class DefaultUpdatableStatesMachine<T : State>(
             val job = previousState.mapOnPresented {
                 statesJobs.remove(it)
             } ?.takeIf { it.isActive } ?: scope.launch {
-                runCatching {
+                performUpdate(actualState)
-                    performUpdate(actualState)
-                }.onFailure {
-                    logger.e(it) {
-                        "Unable to perform update of state up to $actualState"
-                    }
-                }.getOrThrow()
             }.also { job ->
                 job.invokeOnCompletion { _ ->
                     scope.launch {

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/managers/DefaultStatesManager.kt

@@ -1,11 +1,10 @@
 package dev.inmo.micro_utils.fsm.common.managers
 
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.micro_utils.fsm.common.StatesManager
 import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 /**
  * Implement this repo if you want to use some custom repo for [DefaultStatesManager]
@@ -20,14 +19,6 @@ interface DefaultStatesManagerRepo<T : State> {
      * NOT be removed
      */
     suspend fun removeState(state: T)
-
-    /**
-     * Semantically, calls [removeState] and then [set]
-     */
-    suspend fun removeAndSet(toRemove: T, toSet: T) {
-        removeState(toRemove)
-        set(toSet)
-    }
     /**
      * @return Current list of available and saved states
      */
@@ -67,7 +58,7 @@ open class DefaultStatesManager<T : State>(
     protected val _onEndChain = MutableSharedFlow<T>(0)
     override val onEndChain: Flow<T> = _onEndChain.asSharedFlow()
 
-    protected val internalLocker = SmartRWLocker()
+    protected val mapMutex = Mutex()
 
     constructor(
         repo: DefaultStatesManagerRepo<T>,
@@ -77,30 +68,28 @@ open class DefaultStatesManager<T : State>(
         onUpdateContextsConflictResolver = onContextsConflictResolver
     )
 
-    override suspend fun update(old: T, new: T) = internalLocker.withWriteLock {
+    override suspend fun update(old: T, new: T) = mapMutex.withLock {
         val stateByOldContext: T? = repo.getContextState(old.context)
         when {
-            stateByOldContext != old -> return@withWriteLock
+            stateByOldContext != old -> return@withLock
-            old.context == new.context -> {
+            stateByOldContext == null || old.context == new.context -> {
-                repo.removeAndSet(old, new)
+                repo.removeState(old)
+                repo.set(new)
                 _onChainStateUpdated.emit(old to new)
             }
-            old.context != new.context -> {
+            else -> {
                 val stateOnNewOneContext = repo.getContextState(new.context)
                 if (stateOnNewOneContext == null || onUpdateContextsConflictResolver(old, new, stateOnNewOneContext)) {
                     stateOnNewOneContext ?.let { endChainWithoutLock(it) }
-                    repo.removeAndSet(old, new)
+                    repo.removeState(old)
+                    repo.set(new)
                     _onChainStateUpdated.emit(old to new)
-                } else {
-                    error(
-                        "Unable to update state from $old to $new due to false answer from $onUpdateContextsConflictResolver and state on old context $stateOnNewOneContext"
-                    )
                 }
             }
         }
     }
 
-    override suspend fun startChain(state: T) = internalLocker.withWriteLock {
+    override suspend fun startChain(state: T) = mapMutex.withLock {
         val stateOnContext = repo.getContextState(state.context)
         if (stateOnContext == null || onStartContextsConflictResolver(stateOnContext, state)) {
             stateOnContext ?.let {
@@ -119,13 +108,11 @@ open class DefaultStatesManager<T : State>(
     }
 
     override suspend fun endChain(state: T) {
-        internalLocker.withWriteLock {
+        mapMutex.withLock {
             endChainWithoutLock(state)
         }
     }
 
-    override suspend fun getActiveStates(): List<T> = internalLocker.withReadAcquire {
+    override suspend fun getActiveStates(): List<T> = repo.getStates()
-        repo.getStates()
-    }
 
 }

fsm/repos/common/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {

fsm/repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/repos/common/KeyValueBasedDefaultStatesManagerRepo.kt

@@ -1,59 +1,25 @@
 package dev.inmo.micro_utils.fsm.repos.common
 
-import dev.inmo.kslog.common.TagLogger
-import dev.inmo.kslog.common.i
-import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.withReadAcquire
-import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.micro_utils.fsm.common.managers.DefaultStatesManagerRepo
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.pagination.getAll
-import dev.inmo.micro_utils.repos.unset
 
 class KeyValueBasedDefaultStatesManagerRepo<T : State>(
     private val keyValueRepo: KeyValueRepo<Any, T>
 ) : DefaultStatesManagerRepo<T> {
-    private val locker = SmartRWLocker()
-    private val logger = TagLogger("KeyValueBasedDefaultStatesManagerRepo")
     override suspend fun set(state: T) {
-        locker.withWriteLock {
+        keyValueRepo.set(state.context, state)
-            keyValueRepo.set(state.context, state)
-            logger.i { "Set ${state.context} value to $state" }
-        }
     }
 
     override suspend fun removeState(state: T) {
-        locker.withWriteLock {
+        if (keyValueRepo.get(state.context) == state) {
-            if (keyValueRepo.get(state.context) == state) {
+            keyValueRepo.unset(state.context)
-                keyValueRepo.unset(state.context)
-                logger.i { "Unset $state" }
-            }
         }
     }
 
-    override suspend fun removeAndSet(toRemove: T, toSet: T) {
+    override suspend fun getStates(): List<T> = keyValueRepo.getAll { keys(it) }.map { it.second }
-        locker.withWriteLock {
+    override suspend fun getContextState(context: Any): T? = keyValueRepo.get(context)
-            when {
-                toRemove.context == toSet.context -> {
-                    keyValueRepo.set(toSet.context, toSet)
-                }
-                else -> {
-                    keyValueRepo.set(toSet.context, toSet)
-                    keyValueRepo.unset(toRemove)
-                }
-            }
-        }
-    }
 
-    override suspend fun getStates(): List<T> = locker.withReadAcquire {
+    override suspend fun contains(context: Any): Boolean = keyValueRepo.contains(context)
-        keyValueRepo.getAll { keys(it) }.map { it.second }
-    }
-    override suspend fun getContextState(context: Any): T? = locker.withReadAcquire {
-        keyValueRepo.get(context)
-    }
-
-    override suspend fun contains(context: Any): Boolean = locker.withReadAcquire {
-        keyValueRepo.contains(context)
-    }
 }

github_release.gradle

@@ -11,20 +11,12 @@ private String getCurrentVersionChangelog() {
     return changelogDataOS.toString().trim()
 }
 
-
+if (new File(projectDir, "secret.gradle").exists()) {
-def githubTokenVariableName = "GITHUB_RELEASE_TOKEN"
+    apply from: './secret.gradle'
-def githubTokenVariableFromEnv = System.getenv(githubTokenVariableName)
-
-def secretFile = new File(projectDir, "secret.gradle")
-if (secretFile.exists() || project.hasProperty(githubTokenVariableName) || (githubTokenVariableFromEnv != "" && githubTokenVariableFromEnv != null)) {
-    if (secretFile.exists()) {
-        apply from: './secret.gradle'
-    }
     apply plugin: "com.github.breadmoirai.github-release"
-    def githubReleaseToken = project.hasProperty(githubTokenVariableName) ? project.property(githubTokenVariableName).toString() : githubTokenVariableFromEnv
 
     githubRelease {
-        token githubReleaseToken
+        token "${project.property('GITHUB_RELEASE_TOKEN')}"
 
         owner = "InsanusMokrassar"
         repo = "MicroUtils"

gradle.properties

@@ -8,9 +8,6 @@ android.useAndroidX=true
 android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=2g
 
-# https://github.com/google/ksp/issues/2491
-ksp.useKSP2=false
-
 # JS NPM
 
 crypto_js_version=4.1.1
@@ -18,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.26.0
+version=0.24.1
-android_code_version=299
+android_code_version=280

gradle/karma.config.d/timeout.js

@@ -1,7 +0,0 @@
-config.set({
-    client: {
-        mocha: {
-            timeout: 240000
-        }
-    }
-});

gradle/libs.versions.toml

@@ -1,49 +1,47 @@
 [versions]
 
-kt = "2.2.0"
+kt = "2.1.0"
-kt-serialization = "1.9.0"
+kt-serialization = "1.8.0"
-kt-coroutines = "1.10.2"
+kt-coroutines = "1.10.1"
 
-kotlinx-browser = "0.3"
+kslog = "1.4.0"
 
-kslog = "1.5.0"
+jb-compose = "1.7.3"
-
+jb-exposed = "0.57.0"
-jb-compose = "1.8.1"
-jb-exposed = "0.61.0"
 jb-dokka = "2.0.0"
 
-sqlite = "3.50.1.0"
+sqlite = "3.47.2.0"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "3.2.1"
+ktor = "3.0.3"
 
 gh-release = "2.5.2"
 
-koin = "4.1.0"
+koin = "4.0.1"
 
-okio = "3.15.0"
+okio = "3.10.2"
 
-ksp = "2.2.0-2.0.2"
+ksp = "2.1.0-1.0.29"
-kotlin-poet = "2.2.0"
+kotlin-poet = "1.18.1"
 
 versions = "0.51.0"
-nmcp = "1.0.1"
 
-android-gradle = "8.9.+"
+android-gradle = "8.2.2"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.16.0"
+android-coreKtx = "1.15.0"
-android-recyclerView = "1.4.0"
+android-recyclerView = "1.3.2"
-android-appCompat = "1.7.1"
+android-appCompat = "1.7.0"
-android-fragment = "1.8.8"
+android-fragment = "1.8.5"
 android-espresso = "3.6.1"
 android-test = "1.2.1"
+android-compose-material3 = "1.3.0"
 
 android-props-minSdk = "21"
-android-props-compileSdk = "36"
+android-props-compileSdk = "35"
-android-props-buildTools = "36.0.0"
+android-props-buildTools = "35.0.0"
 
 [libraries]
 
@@ -58,7 +56,6 @@ kt-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-and
 kt-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kt-coroutines" }
 kt-coroutines-debug = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-debug", version.ref = "kt-coroutines" }
 
-kotlinx-browser = { module = "org.jetbrains.kotlinx:kotlinx-browser-wasm-js", version.ref = "kotlinx-browser" }
 
 ktor-io = { module = "io.ktor:ktor-io", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
@@ -124,4 +121,3 @@ jb-compose = { id = "org.jetbrains.compose", version.ref = "jb-compose" }
 kt-jb-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kt" }
 
 versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }
-nmcp-aggregation = { id = "com.gradleup.nmcp.aggregation", version.ref = "nmcp" }

gradle/templates/addCompose.gradle

@@ -1,9 +0,0 @@
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                implementation compose.runtime
-            }
-        }
-    }
-}

gradle/templates/addComposeForAndroid.gradle

@@ -1,9 +0,0 @@
-kotlin {
-    sourceSets {
-        androidUnitTest {
-            dependencies {
-                implementation compose.uiTest
-            }
-        }
-    }
-}

gradle/templates/addComposeForDesktop.gradle

@@ -1,15 +0,0 @@
-kotlin {
-    sourceSets {
-        jvmMain {
-            dependencies {
-                implementation compose.desktop.currentOs
-            }
-        }
-        jvmTest {
-            dependencies {
-                implementation kotlin('test-junit')
-                implementation compose.uiTest
-            }
-        }
-    }
-}

gradle/templates/addComposeForJs.gradle

@@ -1,9 +0,0 @@
-kotlin {
-    sourceSets {
-        jsMain {
-            dependencies {
-                implementation compose.web.core
-            }
-        }
-    }
-}

gradle/templates/defaultProject.gradle

@@ -1,24 +0,0 @@
-project.version = "$version"
-project.group = "$group"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                implementation kotlin('stdlib')
-            }
-        }
-        commonTest {
-            dependencies {
-                implementation kotlin('test-common')
-                implementation kotlin('test-annotations-common')
-                implementation libs.kt.coroutines.test
-            }
-        }
-    }
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_17
-}

gradle/templates/defaultProjectWithSerialization.gradle

@@ -1,25 +0,0 @@
-project.version = "$version"
-project.group = "$group"
-
-kotlin {
-    sourceSets {
-        commonMain {
-            dependencies {
-                implementation kotlin('stdlib')
-                api libs.kt.serialization
-            }
-        }
-        commonTest {
-            dependencies {
-                implementation kotlin('test-common')
-                implementation kotlin('test-annotations-common')
-                implementation libs.kt.coroutines.test
-            }
-        }
-    }
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_17
-}

gradle/templates/enableMPPAndroid.gradle

@@ -1,31 +0,0 @@
-kotlin {
-    androidTarget {
-        publishAllLibraryVariants()
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "17"
-            }
-        }
-    }
-
-    sourceSets {
-        androidUnitTest {
-            dependencies {
-                implementation kotlin('test-junit')
-                implementation libs.android.test.junit
-                implementation libs.android.espresso
-            }
-        }
-        androidInstrumentedTest {
-            dependencies {
-                implementation kotlin('test-junit')
-                implementation libs.android.test.junit
-                implementation libs.android.espresso
-            }
-        }
-
-        androidMain.dependsOn jvmMain
-    }
-}
-
-apply from: "$defaultAndroidSettings"

gradle/templates/enableMPPJs.gradle

@@ -1,30 +0,0 @@
-kotlin {
-    js (IR) {
-        browser {
-            testTask {
-                useMocha {
-                    timeout = "240000"
-                }
-            }
-        }
-        nodejs {
-            testTask {
-                useMocha {
-                    timeout = "240000"
-                }
-            }
-        }
-    }
-
-    sourceSets {
-        jsMain {
-            dependencies {
-            }
-        }
-        jsTest {
-            dependencies {
-                implementation kotlin('test-js')
-            }
-        }
-    }
-}

gradle/templates/enableMPPJvm.gradle

@@ -1,21 +0,0 @@
-kotlin {
-    jvm {
-        compilations.main {
-            kotlinOptions {
-                jvmTarget = "17"
-            }
-        }
-    }
-
-    sourceSets {
-        jvmMain {
-            dependencies {
-            }
-        }
-        jvmTest {
-            dependencies {
-                implementation kotlin('test-junit')
-            }
-        }
-    }
-}

gradle/templates/enableMPPNativeArm64.gradle

@@ -1,8 +0,0 @@
-kotlin {
-    linuxArm64()
-
-    sourceSets {
-        nativeMain.dependsOn commonMain
-        linuxArm64Main.dependsOn nativeMain
-    }
-}

gradle/templates/enableMPPNativeX64.gradle

@@ -1,10 +0,0 @@
-kotlin {
-    linuxX64()
-    mingwX64()
-
-    sourceSets {
-        nativeMain.dependsOn commonMain
-        linuxX64Main.dependsOn nativeMain
-        mingwX64Main.dependsOn nativeMain
-    }
-}

gradle/templates/enableMPPWasmJs.gradle

@@ -1,27 +0,0 @@
-kotlin {
-    wasmJs {
-        browser {
-            testTask {
-                useKarma {
-                    useChromeHeadless()
-                    useConfigDirectory(rootProject.relativeProjectPath("gradle/karma.config.d"))
-                }
-            }
-        }
-        nodejs {
-            testTask {
-                timeout = Duration.ofSeconds(240)
-                nodeJsArgs.add("--unhandled-rejections=warn")
-                nodeJsArgs.add("--trace-warnings")
-            }
-        }
-    }
-
-    sourceSets {
-        wasmJsTest {
-            dependencies {
-                implementation kotlin('test-wasm-js')
-            }
-        }
-    }
-}

gradle/templates/mppAndroidProject.gradle

@@ -1,6 +1,37 @@
-apply from: "$defaultProject"
+project.version = "$version"
-apply from: "$enableMPPJvm"
+project.group = "$group"
-apply from: "$enableMPPJs"
+
-apply from: "$enableMPPWasmJs"
-apply from: "$enableMPPAndroid"
 apply from: "$publish"
+
+kotlin {
+    androidTarget {
+        publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+    }
+}
+
+apply from: "$defaultAndroidSettings"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

gradle/templates/mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -0,0 +1,108 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publish"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+        nodejs {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+    }
+    androidTarget {
+        publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    linuxX64()
+    mingwX64()
+    linuxArm64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                implementation compose.runtime
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        androidUnitTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+                implementation compose.uiTest
+            }
+        }
+        androidInstrumentedTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+            }
+        }
+        jvmMain {
+            dependencies {
+                implementation compose.desktop.currentOs
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation compose.uiTest
+            }
+        }
+        jsMain {
+            dependencies {
+                implementation compose.web.core
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+            }
+        }
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+        linuxArm64Main.dependsOn nativeMain
+
+        androidMain.dependsOn jvmMain
+    }
+}
+
+apply from: "$defaultAndroidSettings"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

gradle/templates/mppComposeJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -1,12 +0,0 @@
-apply from: "$defaultProjectWithSerialization"
-apply from: "$enableMPPJvm"
-apply from: "$enableMPPJs"
-apply from: "$enableMPPWasmJs"
-apply from: "$enableMPPAndroid"
-apply from: "$enableMPPNativeX64"
-apply from: "$enableMPPNativeArm64"
-apply from: "$addCompose"
-apply from: "$addComposeForAndroid"
-apply from: "$addComposeForDesktop"
-apply from: "$addComposeForJs"
-apply from: "$publish"

gradle/templates/mppJavaProject.gradle

@@ -1,3 +1,40 @@
-apply from: "$defaultProject"
+project.version = "$version"
-apply from: "$enableMPPJvm"
+project.group = "$group"
+
 apply from: "$publish"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

gradle/templates/mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -0,0 +1,88 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publish"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+        nodejs {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+    }
+    androidTarget {
+        publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    linuxX64()
+    mingwX64()
+    linuxArm64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        androidUnitTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+            }
+        }
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+        linuxArm64Main.dependsOn nativeMain
+
+        androidMain.dependsOn jvmMain
+    }
+}
+
+apply from: "$defaultAndroidSettings"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

gradle/templates/mppJvmJsLinuxMingwProject.gradle

@@ -0,0 +1,70 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publish"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+        nodejs {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+    }
+    linuxX64()
+    mingwX64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+            }
+        }
+
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+
+        androidMain.dependsOn jvmMain
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

gradle/templates/mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -1,8 +0,0 @@
-apply from: "$defaultProjectWithSerialization"
-apply from: "$enableMPPJvm"
-apply from: "$enableMPPJs"
-apply from: "$enableMPPWasmJs"
-apply from: "$enableMPPAndroid"
-apply from: "$enableMPPNativeX64"
-apply from: "$enableMPPNativeArm64"
-apply from: "$publish"

gradle/templates/mppJvmJsWasmJsLinuxMingwProject.gradle

@@ -1,6 +0,0 @@
-apply from: "$defaultProjectWithSerialization"
-apply from: "$enableMPPJvm"
-apply from: "$enableMPPJs"
-apply from: "$enableMPPWasmJs"
-apply from: "$enableMPPNativeX64"
-apply from: "$publish"

gradle/templates/mppProjectWithSerializationAndCompose.gradle

@@ -1,10 +1,98 @@
-apply from: "$defaultProjectWithSerialization"
+project.version = "$version"
-apply from: "$enableMPPJvm"
+project.group = "$group"
-apply from: "$enableMPPJs"
+
-apply from: "$enableMPPWasmJs"
-apply from: "$enableMPPAndroid"
-apply from: "$addCompose"
-apply from: "$addComposeForAndroid"
-apply from: "$addComposeForDesktop"
-apply from: "$addComposeForJs"
 apply from: "$publish"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+        nodejs {
+            testTask {
+                useMocha {
+                    timeout = "60000"
+                }
+            }
+        }
+    }
+    androidTarget {
+        publishAllLibraryVariants()
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                implementation compose.runtime
+                api libs.kt.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+                implementation libs.kt.coroutines.test
+            }
+        }
+        jvmMain {
+            dependencies {
+                implementation compose.desktop.currentOs
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation compose.uiTest
+            }
+        }
+        jsMain {
+            dependencies {
+                implementation compose.web.core
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+            }
+        }
+        androidUnitTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+                implementation compose.uiTest
+            }
+        }
+    }
+}
+
+apply from: "$defaultAndroidSettings"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+
+//compose {
+//    if (composePluginKotlinVersion != null && !composePluginKotlinVersion.isEmpty()) {
+//        kotlinCompilerPlugin.set(composePluginKotlinVersion)
+//    }
+//}

gradle/templates/publish.gradle

@@ -19,58 +19,66 @@ publishing {
             }
 
             developers {
-                developer {
+                
-                    id = "InsanusMokrassar"
+                    developer {
-                    name = "Aleksei Ovsiannikov"
+                        id = "InsanusMokrassar"
-                    email = "ovsyannikov.alexey95@gmail.com"
+                        name = "Aleksei Ovsiannikov"
-                }
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
 
-                developer {
+                    developer {
-                    id = "000Sanya"
+                        id = "000Sanya"
-                    name = "Syrov Aleksandr"
+                        name = "Syrov Aleksandr"
-                    email = "000sanya.000sanya@gmail.com"
+                        email = "000sanya.000sanya@gmail.com"
-                }
+                    }
+                
             }
 
             licenses {
-                license {
+                
-                    name = "Apache Software License 2.0"
+                    license {
-                    url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
+                        name = "Apache Software License 2.0"
-                }
+                        url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
+                    }
+                
             }
         }
-    }
+        repositories {
-    repositories {
+            if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
-        if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
+                maven {
-            maven {
+                    name = "GithubPackages"
-                name = "GithubPackages"
+                    url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
-                url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+            
-        
+                    credentials {
-                credentials {
+                        username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
-                    username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
+                        password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
-                    password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
+                    }
+            
                 }
             }
-        }
+            if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
-        if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
+                maven {
-            maven {
+                    name = "InmoNexus"
-                name = "InmoNexus"
+                    url = uri("https://nexus.inmo.dev/repository/maven-releases/")
-                url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+            
-        
+                    credentials {
-                credentials {
+                        username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
-                    username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                        password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
-                    password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
+                    }
+            
                 }
             }
-        }
+            if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-        if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                maven {
-            maven {
+                    name = "sonatype"
-                name = "sonatype"
+                    url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                url = uri("https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/")
+            
-        
+                    credentials {
-                credentials {
+                        username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                    username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                    password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                    }
+            
                 }
             }
         }
@@ -79,13 +87,13 @@ publishing {
     
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-
+    
     signing {
         useGpgCmd()
-
+    
         sign publishing.publications
     }
-
+    
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

gradle/templates/publish.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"},"includeCentralSonatypeUploadingScript":false}}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

gradle/templates/publish_jvm.gradle

@@ -1,6 +1,5 @@
 apply plugin: 'maven-publish'
 
-
 task javadocJar(type: Jar) {
     from javadoc
     archiveClassifier = 'javadoc'
@@ -56,39 +55,42 @@ publishing {
                     
                 }
             }
-        }
+            repositories {
-    }
+                if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
-    repositories {
+                    maven {
-        if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
+                        name = "GithubPackages"
-            maven {
+                        url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
-                name = "GithubPackages"
+                
-                url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+                        credentials {
-        
+                            username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
-                credentials {
+                            password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
-                    username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
+                        }
-                    password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
+                
+                    }
                 }
-            }
+                if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
-        }
+                    maven {
-        if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
+                        name = "InmoNexus"
-            maven {
+                        url = uri("https://nexus.inmo.dev/repository/maven-releases/")
-                name = "InmoNexus"
+                
-                url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+                        credentials {
-        
+                            username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
-                credentials {
+                            password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
-                    username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                        }
-                    password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
+                
+                    }
                 }
-            }
+                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
-        }
+                    maven {
-        if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                        name = "sonatype"
-            maven {
+                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-                name = "sonatype"
+                
-                url = uri("https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/")
+                        credentials {
-        
+                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
-                credentials {
+                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
-                    username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        }
-                    password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                
+                    }
                 }
             }
         }
@@ -97,13 +99,13 @@ publishing {
 
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-
+    
     signing {
         useGpgCmd()
-
+    
         sign publishing.publications
     }
-
+    
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

gradle/templates/publish_jvm.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"},"includeCentralSonatypeUploadingScript":false},"type":"JVM"}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"It is set of projects with micro tools for avoiding of routines coding","url":"https://github.com/InsanusMokrassar/MicroUtils/","vcsUrl":"https://github.com/InsanusMokrassar/MicroUtils.git","developers":[{"id":"InsanusMokrassar","name":"Aleksei Ovsiannikov","eMail":"ovsyannikov.alexey95@gmail.com"},{"id":"000Sanya","name":"Syrov Aleksandr","eMail":"000sanya.000sanya@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/MicroUtils"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}},"type":"JVM"}

gradle/wrapper/gradle-wrapper.properties

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

koin/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "com.android.library"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
     sourceSets {
@@ -17,13 +17,11 @@ kotlin {
         jvmMain {
             dependencies {
                 api libs.kt.reflect
-                api project(":micro_utils.coroutines")
             }
         }
         androidMain {
             dependencies {
                 api libs.kt.reflect
-                api project(":micro_utils.coroutines")
             }
         }
     }

koin/generator/build.gradle

@@ -10,7 +10,6 @@ repositories {
 
 dependencies {
     api project(":micro_utils.koin")
-    api project(":micro_utils.ksp.generator")
     api libs.kotlin.poet
     api libs.ksp
 }

koin/generator/src/main/kotlin/Processor.kt

@@ -26,7 +26,6 @@ import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.toTypeName
 import com.squareup.kotlinpoet.ksp.writeTo
-import dev.inmo.micro_ksp.generator.safeClassName
 import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition
 import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import org.koin.core.Koin
@@ -238,7 +237,15 @@ class Processor(
                     """.trimIndent()
                 )
                 ksFile.getAnnotationsByType(GenerateKoinDefinition::class).forEach {
-                    val type = safeClassName { it.type }
+                    val type = runCatching {
+                        it.type.asTypeName()
+                    }.getOrElse { e ->
+                        if (e is KSTypeNotPresentException) {
+                            e.ksType.toClassName()
+                        } else {
+                            throw e
+                        }
+                    }
                     val targetType = runCatching {
                         type.parameterizedBy(*(it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type))
                     }.getOrElse { e ->

koin/generator/test/build.gradle

@@ -5,7 +5,7 @@ plugins {
     id "com.google.devtools.ksp"
 }
 
-apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 
 kotlin {

koin/generator/test/src/commonMain/kotlin/GeneratedDefinitionsTest.kt

@@ -5,6 +5,7 @@ package dev.inmo.micro_utils.koin.generator.test
 
 import kotlin.Any
 import kotlin.Boolean
+import kotlin.Deprecated
 import kotlin.String
 import org.koin.core.Koin
 import org.koin.core.definition.Definition
@@ -29,59 +30,95 @@ public val Koin.sampleInfo: Test<String>
 /**
  * @return Definition by key "sampleInfo" with [parameters]
  */
-public inline fun Scope.sampleInfo(noinline parameters: ParametersDefinition): Test<String> = get(named("sampleInfo"), parameters)
+public inline fun Scope.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
 
 /**
  * @return Definition by key "sampleInfo" with [parameters]
  */
-public inline fun Koin.sampleInfo(noinline parameters: ParametersDefinition): Test<String> = get(named("sampleInfo"), parameters)
+public inline fun Koin.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
  */
-public fun Module.singleSampleInfo(createdAtStart: Boolean = false, definition: Definition<Test<String>>): KoinDefinition<Test<String>> = single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use singleSampleInfo instead",
+  ReplaceWith("singleSampleInfo"),
+)
+public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
+    definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
+ */
+public fun Module.singleSampleInfo(createdAtStart: Boolean = false,
+    definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
  */
-public fun Module.factorySampleInfo(definition: Definition<Test<String>>): KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use factorySampleInfo instead",
+  ReplaceWith("factorySampleInfo"),
+)
+public fun Module.sampleInfoFactory(definition: Definition<Test<String>>):
+    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
+ */
+public fun Module.factorySampleInfo(definition: Definition<Test<String>>):
+    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
 
 /**
  * @return Definition by key "test" with [parameters]
  */
-public inline fun <reified T : Any> Scope.test(noinline parameters: ParametersDefinition? = null): T = get(named("test"), parameters)
+public inline fun <reified T : Any> Scope.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
 
 /**
  * @return Definition by key "test" with [parameters]
  */
-public inline fun <reified T : Any> Koin.test(noinline parameters: ParametersDefinition? = null): T = get(named("test"), parameters)
+public inline fun <reified T : Any> Koin.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.single] and key "test"
  */
-public inline fun <reified T : Any> Module.singleTest(createdAtStart: Boolean = false, noinline definition: Definition<T>): KoinDefinition<T> = single(named("test"), createdAtStart = createdAtStart, definition = definition)
+public inline fun <reified T : Any> Module.singleTest(createdAtStart: Boolean = false, noinline
+    definition: Definition<T>): KoinDefinition<T> = single(named("test"), createdAtStart =
+    createdAtStart, definition = definition)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.factory] and key "test"
  */
-public inline fun <reified T : Any> Module.factoryTest(noinline definition: Definition<T>): KoinDefinition<T> = factory(named("test"), definition = definition)
+public inline fun <reified T : Any> Module.factoryTest(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("test"), definition = definition)
 
 /**
  * @return Definition by key "testNullable" with [parameters]
  */
-public inline fun <reified T : Any> Scope.testNullable(noinline parameters: ParametersDefinition? = null): T? = getOrNull(named("testNullable"), parameters)
+public inline fun <reified T : Any> Scope.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
 
 /**
  * @return Definition by key "testNullable" with [parameters]
  */
-public inline fun <reified T : Any> Koin.testNullable(noinline parameters: ParametersDefinition? = null): T? = getOrNull(named("testNullable"), parameters)
+public inline fun <reified T : Any> Koin.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.single] and key "testNullable"
  */
-public inline fun <reified T : Any> Module.singleTestNullable(createdAtStart: Boolean = false, noinline definition: Definition<T>): KoinDefinition<T> = single(named("testNullable"), createdAtStart = createdAtStart, definition = definition)
+public inline fun <reified T : Any> Module.singleTestNullable(createdAtStart: Boolean = false,
+    noinline definition: Definition<T>): KoinDefinition<T> = single(named("testNullable"),
+    createdAtStart = createdAtStart, definition = definition)
 
 /**
  * Will register [definition] with [org.koin.core.module.Module.factory] and key "testNullable"
  */
-public inline fun <reified T : Any> Module.factoryTestNullable(noinline definition: Definition<T>): KoinDefinition<T> = factory(named("testNullable"), definition = definition)
+public inline fun <reified T : Any> Module.factoryTestNullable(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("testNullable"), definition = definition)

koin/src/commonMain/kotlin/FactoryWithRandomQualifier.kt

@@ -4,14 +4,8 @@ import org.koin.core.definition.Definition
 import org.koin.core.module.Module
 
 /**
- * Declares a factory with a random qualifier in the Koin module.
+ * Will be useful in case you need to declare some singles with one type several types, but need to separate them and do
- * This is useful when you need to declare multiple factory definitions of the same type
+ * not care about how :)
- * but want them to be uniquely identifiable without manually specifying qualifiers.
- * Unlike singles, factories create a new instance each time they are requested.
- *
- * @param T The type of instance to be created by the factory
- * @param definition The definition function that creates new instances
- * @return A Koin definition for the factory with a random qualifier
  */
 inline fun <reified T : Any> Module.factoryWithRandomQualifier(
     noinline definition: Definition<T>

koin/src/commonMain/kotlin/FactoryWithStringQualifier.kt

@@ -4,16 +4,6 @@ import org.koin.core.definition.Definition
 import org.koin.core.module.Module
 import org.koin.core.qualifier.StringQualifier
 
-/**
- * Declares a factory with a string qualifier in the Koin module.
- * This is a convenience function that wraps the string qualifier in a [StringQualifier].
- * Unlike singles, factories create a new instance each time they are requested.
- *
- * @param T The type of instance to be created by the factory
- * @param qualifier The string value to be used as a qualifier
- * @param definition The definition function that creates new instances
- * @return A Koin definition for the factory with the specified string qualifier
- */
 inline fun <reified T : Any> Module.factory(
     qualifier: String,
     noinline definition: Definition<T>