fill changelog

0.24.8

CHANGELOG.md

@@ -1,5 +1,91 @@
 # Changelog
 
+## 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`:
+  * `Serialization`: `1.7.3` -> `1.8.0`
+  * `SQLite`: `3.47.1.0` -> `3.47.2.0`
+  * `Koin`: `4.0.0` -> `3.10.2`
+  * `OKio`: `3.9.1` -> `3.10.2`
+
 ## 0.24.0
 
 * `Versions`:

common/compose/build.gradle

@@ -13,6 +13,7 @@ kotlin {
         commonMain {
             dependencies {
                 api project(":micro_utils.common")
+                api libs.kt.coroutines
             }
         }
     }

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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,6 @@
+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/Retry.kt

@@ -0,0 +1,26 @@
+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")
+}

coroutines/build.gradle

@@ -11,6 +11,7 @@ kotlin {
         commonMain {
             dependencies {
                 api libs.kt.coroutines
+                api libs.kslog
             }
         }
         jsMain {

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,6 +2,7 @@
 
 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
@@ -16,6 +17,45 @@ 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,
@@ -29,6 +69,10 @@ 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,
@@ -42,6 +86,10 @@ 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.launchSafelyWithoutExceptions {
+        scope.launchLoggingDropExceptions {
             for (data in dataChannel) {
                 output(data)
             }

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

@@ -15,6 +15,10 @@ 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
@@ -29,6 +33,10 @@ 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
@@ -39,10 +47,18 @@ 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> {
@@ -73,6 +89,9 @@ 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,
@@ -94,6 +113,10 @@ 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
@@ -104,9 +127,17 @@ 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() }
@@ -137,11 +168,19 @@ 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

@@ -0,0 +1,55 @@
+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,6 +4,10 @@ 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,
@@ -15,6 +19,10 @@ 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,
@@ -26,6 +34,10 @@ 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,
@@ -37,6 +49,10 @@ 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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,12 @@
+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/collections/SortedBinaryTreeNode.kt

@@ -0,0 +1,319 @@
+package dev.inmo.micro_utils.coroutines.collections
+
+import dev.inmo.micro_utils.coroutines.SmartRWLocker
+import dev.inmo.micro_utils.coroutines.waitReadRelease
+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>.addSubNode(
+    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 addSubNode(
+        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 -> addSubNode(leftNode, setOf(locker)) }
+        right ?.also { rightNode -> addSubNode(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/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/HandleSafelyCoroutineContextTest.kt

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

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

@@ -0,0 +1,176 @@
+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)
+    }
+}

fsm/common/build.gradle

@@ -12,6 +12,7 @@ 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,5 +1,7 @@
 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
@@ -68,6 +70,7 @@ 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
      */
@@ -96,7 +99,13 @@ open class DefaultStatesMachine <T: State>(
         statesJobsMutex.withLock {
             statesJobs[actualState] ?.cancel()
             statesJobs[actualState] = scope.launch {
-                performUpdate(actualState)
+                runCatching {
+                    performUpdate(actualState)
+                }.onFailure {
+                    logger.e(it) {
+                        "Unable to perform update of state from $actualState"
+                    }
+                }.getOrThrow()
             }.also { job ->
                 job.invokeOnCompletion { _ ->
                     scope.launch {
@@ -119,8 +128,10 @@ open class DefaultStatesMachine <T: State>(
      */
     override fun start(scope: CoroutineScope): Job {
         val supervisorScope = scope.LinkedSupervisorScope()
-        supervisorScope.launchSafelyWithoutExceptions {
-            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(supervisorScope) {
+        supervisorScope.launchLoggingDropExceptions {
+            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(
+                supervisorScope
+            ) {
                 supervisorScope.launch { performStateUpdate(Optional.absent(), it, supervisorScope) }
             }
             statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(supervisorScope) {
@@ -131,7 +142,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,7 +9,12 @@ interface StatesManager<T : State> {
 
 
     /**
-     * Must set current set using [State.context]
+     * It is expected, that [new] state will be saved in manager.
+     *
+     * 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,5 +1,6 @@
 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
@@ -44,7 +45,13 @@ open class DefaultUpdatableStatesMachine<T : State>(
             val job = previousState.mapOnPresented {
                 statesJobs.remove(it)
             } ?.takeIf { it.isActive } ?: scope.launch {
-                performUpdate(actualState)
+                runCatching {
+                    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,10 +1,11 @@
 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]
@@ -19,6 +20,14 @@ 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
      */
@@ -58,7 +67,7 @@ open class DefaultStatesManager<T : State>(
     protected val _onEndChain = MutableSharedFlow<T>(0)
     override val onEndChain: Flow<T> = _onEndChain.asSharedFlow()
 
-    protected val mapMutex = Mutex()
+    protected val internalLocker = SmartRWLocker()
 
     constructor(
         repo: DefaultStatesManagerRepo<T>,
@@ -68,28 +77,30 @@ open class DefaultStatesManager<T : State>(
         onUpdateContextsConflictResolver = onContextsConflictResolver
     )
 
-    override suspend fun update(old: T, new: T) = mapMutex.withLock {
+    override suspend fun update(old: T, new: T) = internalLocker.withWriteLock {
         val stateByOldContext: T? = repo.getContextState(old.context)
         when {
-            stateByOldContext != old -> return@withLock
-            stateByOldContext == null || old.context == new.context -> {
-                repo.removeState(old)
-                repo.set(new)
+            stateByOldContext != old -> return@withWriteLock
+            old.context == new.context -> {
+                repo.removeAndSet(old, new)
                 _onChainStateUpdated.emit(old to new)
             }
-            else -> {
+            old.context != new.context -> {
                 val stateOnNewOneContext = repo.getContextState(new.context)
                 if (stateOnNewOneContext == null || onUpdateContextsConflictResolver(old, new, stateOnNewOneContext)) {
                     stateOnNewOneContext ?.let { endChainWithoutLock(it) }
-                    repo.removeState(old)
-                    repo.set(new)
+                    repo.removeAndSet(old, 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) = mapMutex.withLock {
+    override suspend fun startChain(state: T) = internalLocker.withWriteLock {
         val stateOnContext = repo.getContextState(state.context)
         if (stateOnContext == null || onStartContextsConflictResolver(stateOnContext, state)) {
             stateOnContext ?.let {
@@ -108,11 +119,13 @@ open class DefaultStatesManager<T : State>(
     }
 
     override suspend fun endChain(state: T) {
-        mapMutex.withLock {
+        internalLocker.withWriteLock {
             endChainWithoutLock(state)
         }
     }
 
-    override suspend fun getActiveStates(): List<T> = repo.getStates()
+    override suspend fun getActiveStates(): List<T> = internalLocker.withReadAcquire {
+        repo.getStates()
+    }
 
 }

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

@@ -1,25 +1,59 @@
 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) {
-        keyValueRepo.set(state.context, state)
-    }
-
-    override suspend fun removeState(state: T) {
-        if (keyValueRepo.get(state.context) == state) {
-            keyValueRepo.unset(state.context)
+        locker.withWriteLock {
+            keyValueRepo.set(state.context, state)
+            logger.i { "Set ${state.context} value to $state" }
         }
     }
 
-    override suspend fun getStates(): List<T> = keyValueRepo.getAll { keys(it) }.map { it.second }
-    override suspend fun getContextState(context: Any): T? = keyValueRepo.get(context)
+    override suspend fun removeState(state: T) {
+        locker.withWriteLock {
+            if (keyValueRepo.get(state.context) == state) {
+                keyValueRepo.unset(state.context)
+                logger.i { "Unset $state" }
+            }
+        }
+    }
 
-    override suspend fun contains(context: Any): Boolean = keyValueRepo.contains(context)
+    override suspend fun removeAndSet(toRemove: T, toSet: T) {
+        locker.withWriteLock {
+            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 {
+        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)
+    }
 }

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.24.0
-android_code_version=279
+version=0.24.9
+android_code_version=289

gradle/libs.versions.toml

@@ -1,43 +1,42 @@
 [versions]
 
-kt = "2.1.0"
-kt-serialization = "1.7.3"
+kt = "2.1.10"
+kt-serialization = "1.8.0"
 kt-coroutines = "1.10.1"
 
-kslog = "1.4.0"
+kslog = "1.4.1"
 
 jb-compose = "1.7.3"
-jb-exposed = "0.57.0"
+jb-exposed = "0.59.0"
 jb-dokka = "2.0.0"
 
-sqlite = "3.47.1.0"
+sqlite = "3.49.1.0"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "3.0.3"
+ktor = "3.1.1"
 
 gh-release = "2.5.2"
 
-koin = "4.0.0"
+koin = "4.0.2"
 
-okio = "3.9.1"
+okio = "3.10.2"
 
-ksp = "2.1.0-1.0.29"
+ksp = "2.1.10-1.0.31"
 kotlin-poet = "1.18.1"
 
 versions = "0.51.0"
 
-android-gradle = "8.2.2"
+android-gradle = "8.7.+"
 dexcount = "4.0.0"
 
 android-coreKtx = "1.15.0"
-android-recyclerView = "1.3.2"
+android-recyclerView = "1.4.0"
 android-appCompat = "1.7.0"
-android-fragment = "1.8.5"
+android-fragment = "1.8.6"
 android-espresso = "3.6.1"
 android-test = "1.2.1"
-android-compose-material3 = "1.3.0"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "35"

gradle/templates/mppComposeJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppJvmJsLinuxMingwProject.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/mppProjectWithSerializationAndCompose.gradle

@@ -15,14 +15,14 @@ kotlin {
         browser {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }
         nodejs {
             testTask {
                 useMocha {
-                    timeout = "60000"
+                    timeout = "240000"
                 }
             }
         }

gradle/templates/publish.gradle

@@ -1,3 +1,7 @@
+if (ext.getProperties()["do_publish"] == false) {
+    return
+}
+
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
@@ -19,29 +23,29 @@ publishing {
             }
 
             developers {
-                
+
                     developer {
                         id = "InsanusMokrassar"
                         name = "Aleksei Ovsiannikov"
                         email = "ovsyannikov.alexey95@gmail.com"
                     }
-                
+
 
                     developer {
                         id = "000Sanya"
                         name = "Syrov Aleksandr"
                         email = "000sanya.000sanya@gmail.com"
                     }
-                
+
             }
 
             licenses {
-                
+
                     license {
                         name = "Apache Software License 2.0"
                         url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
                     }
-                
+
             }
         }
         repositories {
@@ -49,51 +53,51 @@ publishing {
                 maven {
                     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')
                         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 {
                     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')
                         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 {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-            
+
                     credentials {
                         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')
                     }
-            
+
                 }
             }
         }
     }
 }
-    
+
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-    
+
     signing {
         useGpgCmd()
-    
+
         sign publishing.publications
     }
-    
+
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

gradle/wrapper/gradle-wrapper.properties

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

ksp/classcasts/generator/test/build.gradle

@@ -5,6 +5,8 @@ plugins {
     id "com.google.devtools.ksp"
 }
 
+ext.do_publish = false
+
 apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 

ksp/generator/src/main/kotlin/FilesWorkaround.kt

@@ -1,28 +1,38 @@
 package dev.inmo.micro_ksp.generator
 
 import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSDeclaration
 import com.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.KSFunctionDeclaration
 import com.squareup.kotlinpoet.FileSpec
 import java.io.File
 
-fun KSClassDeclaration.writeFile(
+fun KSDeclaration.writeFile(
     prefix: String = "",
     suffix: String = "",
     relatedPath: String = "",
     force: Boolean = false,
+    forceUppercase: Boolean = true,
     fileSpecBuilder: () -> FileSpec
 ) {
     val containingFile = containingFile!!
+    val simpleName = if (forceUppercase) {
+        val rawSimpleName = simpleName.asString()
+        rawSimpleName.replaceFirst(rawSimpleName.first().toString(), rawSimpleName.first().uppercase())
+    } else {
+        simpleName.asString()
+    }
     File(
         File(
             File(containingFile.filePath).parent,
             relatedPath
         ),
-        "$prefix${simpleName.asString()}$suffix.kt"
+        "$prefix${simpleName}$suffix.kt"
     ).takeIf { force || !it.exists() } ?.apply {
         parentFile.mkdirs()
+        val fileSpec = fileSpecBuilder()
         writer().use { writer ->
-            fileSpecBuilder().writeTo(writer)
+            fileSpec.writeTo(writer)
         }
     }
 }
@@ -42,8 +52,9 @@ fun KSFile.writeFile(
         "$prefix${fileName.dropLastWhile { it != '.' }.removeSuffix(".")}$suffix.kt"
     ).takeIf { force || !it.exists() } ?.apply {
         parentFile.mkdirs()
+        val fileSpec = fileSpecBuilder()
         writer().use { writer ->
-            fileSpecBuilder().writeTo(writer)
+            fileSpec.writeTo(writer)
         }
     }
-}
+}

ksp/generator/src/main/kotlin/KClassWorkarounds.kt

@@ -0,0 +1,25 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.KSTypeNotPresentException
+import com.google.devtools.ksp.KSTypesNotPresentException
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.symbol.KSType
+import com.squareup.kotlinpoet.asClassName
+import com.squareup.kotlinpoet.ksp.toClassName
+import kotlin.reflect.KClass
+
+@OptIn(KspExperimental::class)
+inline fun convertToClassName(getter: () -> KClass<*>) = try {
+    getter().asClassName()
+} catch (e: KSTypeNotPresentException) {
+    e.ksType.toClassName()
+}
+
+@OptIn(KspExperimental::class)
+inline fun convertToClassNames(getter: () -> List<KClass<*>>) = try {
+    getter().map { it.asClassName() }
+} catch (e: KSTypesNotPresentException) {
+    e.ksTypes.map {
+        it.toClassName()
+    }
+}

ksp/sealed/generator/src/main/kotlin/KSClassDeclarationGetGenerateSealedWorkaroundAnnotation.kt

@@ -3,9 +3,15 @@ package dev.inmo.micro_utils.ksp.sealed.generator
 import com.google.devtools.ksp.KspExperimental
 import com.google.devtools.ksp.getAnnotationsByType
 import com.google.devtools.ksp.symbol.KSClassDeclaration
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedTypesWorkaround
 import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
 import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround as OldGenerateSealedWorkaround
 
 @OptIn(KspExperimental::class)
 val KSClassDeclaration.getGenerateSealedWorkaroundAnnotation
     get() = (getAnnotationsByType(GenerateSealedWorkaround::class).firstOrNull() ?: getAnnotationsByType(OldGenerateSealedWorkaround::class).firstOrNull())
+
+
+@OptIn(KspExperimental::class)
+val KSClassDeclaration.getGenerateSealedTypesWorkaroundAnnotation
+    get() = getAnnotationsByType(GenerateSealedTypesWorkaround::class).firstOrNull()

ksp/sealed/generator/src/main/kotlin/Processor.kt

@@ -6,21 +6,17 @@ import com.google.devtools.ksp.processing.CodeGenerator
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.symbol.*
-import com.squareup.kotlinpoet.ClassName
-import com.squareup.kotlinpoet.CodeBlock
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.FunSpec
-import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
-import com.squareup.kotlinpoet.PropertySpec
-import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
 import dev.inmo.micro_ksp.generator.buildSubFileName
 import dev.inmo.micro_ksp.generator.companion
 import dev.inmo.micro_ksp.generator.findSubClasses
 import dev.inmo.micro_ksp.generator.writeFile
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedTypesWorkaround
 import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
 import java.io.File
+import kotlin.reflect.KClass
 
 class Processor(
     private val codeGenerator: CodeGenerator
@@ -109,6 +105,62 @@ class Processor(
         )
     }
 
+    @OptIn(KspExperimental::class)
+    private fun FileSpec.Builder.generateSealedTypesWorkaround(
+        ksClassDeclaration: KSClassDeclaration,
+        resolver: Resolver
+    ) {
+        val annotation = ksClassDeclaration.getGenerateSealedTypesWorkaroundAnnotation
+        val subClasses = ksClassDeclaration.resolveSubclasses(
+            searchIn = resolver.getAllFiles(),
+            allowNonSealed = annotation ?.includeNonSealedSubTypes ?: false
+        ).distinct()
+        val subClassesNames = subClasses.filter {
+            it.getAnnotationsByType(GenerateSealedTypesWorkaround.Exclude::class).count() == 0
+        }.sortedBy {
+            (it.getAnnotationsByType(GenerateSealedTypesWorkaround.Order::class).firstOrNull()) ?.order ?: 0
+        }.map {
+            it.toClassName()
+        }.toList()
+        val className = ksClassDeclaration.toClassName()
+        val setType = Set::class.asTypeName().parameterizedBy(
+            KClass::class.asTypeName().parameterizedBy(
+                TypeVariableName(
+                    "out ${ksClassDeclaration.asStarProjectedType().toClassName().simpleNames.joinToString(".")}",
+                )
+            )
+        )
+        addProperty(
+            PropertySpec.builder(
+                "subtypes",
+                setType
+            ).apply {
+                modifiers.add(
+                    KModifier.PRIVATE
+                )
+                initializer(
+                    CodeBlock.of(
+                        """setOf(${subClassesNames.joinToString(",\n") { it.simpleNames.joinToString(".") + "::class" }})"""
+                    )
+                )
+            }.build()
+        )
+        addFunction(
+            FunSpec.builder("subtypes").apply {
+                val companion = ksClassDeclaration.takeIf { it.isCompanionObject } ?.toClassName()
+                    ?: ksClassDeclaration.companion ?.toClassName()
+                    ?: ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion")
+                receiver(companion)
+                returns(setType)
+                addCode(
+                    CodeBlock.of(
+                        """return subtypes"""
+                    )
+                )
+            }.build()
+        )
+    }
+
     @OptIn(KspExperimental::class)
     override fun process(resolver: Resolver): List<KSAnnotated> {
         (resolver.getSymbolsWithAnnotation(GenerateSealedWorkaround::class.qualifiedName!!)).filterIsInstance<KSClassDeclaration>().forEach {
@@ -131,6 +183,26 @@ class Processor(
                 }.build()
             }
         }
+        (resolver.getSymbolsWithAnnotation(GenerateSealedTypesWorkaround::class.qualifiedName!!)).filterIsInstance<KSClassDeclaration>().forEach {
+            val prefix = (it.getGenerateSealedTypesWorkaroundAnnotation) ?.prefix ?.takeIf {
+                it.isNotEmpty()
+            } ?: it.buildSubFileName.replaceFirst(it.simpleName.asString(), "")
+            it.writeFile(prefix = prefix, suffix = "SealedTypesWorkaround") {
+                FileSpec.builder(
+                    it.packageName.asString(),
+                    "${it.simpleName.getShortName()}SealedTypesWorkaround"
+                ).apply {
+                    addFileComment(
+                        """
+                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+                        TO REGENERATE IT JUST DELETE FILE
+                        ORIGINAL FILE: ${it.containingFile ?.fileName}
+                        """.trimIndent()
+                    )
+                    generateSealedTypesWorkaround(it, resolver)
+                }.build()
+            }
+        }
 
         return emptyList()
     }

ksp/sealed/generator/test/build.gradle

@@ -5,6 +5,8 @@ plugins {
     id "com.google.devtools.ksp"
 }
 
+ext.do_publish = false
+
 apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
 
 

ksp/sealed/generator/test/src/commonMain/kotlin/Test.kt

@@ -1,14 +1,19 @@
 package dev.inmo.micro_utils.ksp.sealed.generator.test
 
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedTypesWorkaround
 import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
 
 @GenerateSealedWorkaround
+@GenerateSealedTypesWorkaround
 sealed interface Test {
     @GenerateSealedWorkaround.Order(2)
+    @GenerateSealedTypesWorkaround.Exclude
     object A : Test
     @GenerateSealedWorkaround.Exclude
+    @GenerateSealedTypesWorkaround.Order(2)
     object B : Test
     @GenerateSealedWorkaround.Order(0)
+    @GenerateSealedTypesWorkaround.Order(0)
     object C : Test
 
     // Required for successful sealed workaround generation

ksp/sealed/generator/test/src/commonMain/kotlin/TestSealedTypesWorkaround.kt

@@ -0,0 +1,12 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: Test.kt
+package dev.inmo.micro_utils.ksp.`sealed`.generator.test
+
+import kotlin.collections.Set
+import kotlin.reflect.KClass
+
+private val subtypes: Set<KClass<out Test>> = setOf(Test.C::class,
+    Test.B::class)
+
+public fun Test.Companion.subtypes(): Set<KClass<out Test>> = subtypes

ksp/sealed/generator/test/src/jvmTest/kotlin/TestTests.kt

@@ -0,0 +1,40 @@
+import dev.inmo.micro_utils.ksp.sealed.generator.test.subtypes
+import dev.inmo.micro_utils.ksp.sealed.generator.test.values
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class TestTests {
+    @Test
+    fun testThatAfterCompilationTestWorkaroundsHaveCorrectValues() {
+        val correctValues = arrayOf(
+            dev.inmo.micro_utils.ksp.sealed.generator.test.Test.C,
+            dev.inmo.micro_utils.ksp.sealed.generator.test.Test.A,
+        )
+        val correctSubtypes = arrayOf(
+            dev.inmo.micro_utils.ksp.sealed.generator.test.Test.C::class,
+            dev.inmo.micro_utils.ksp.sealed.generator.test.Test.B::class,
+        )
+
+        assertEquals(
+            correctValues.size, dev.inmo.micro_utils.ksp.sealed.generator.test.Test.values().size
+        )
+        correctValues.forEachIndexed { index, value ->
+            assertTrue(
+                value === dev.inmo.micro_utils.ksp.sealed.generator.test.Test.values().elementAt(index)
+            )
+        }
+
+        assertEquals(
+            correctSubtypes.size, dev.inmo.micro_utils.ksp.sealed.generator.test.Test.subtypes().size
+        )
+        correctSubtypes.forEachIndexed { index, value ->
+            assertTrue(
+                value.qualifiedName != null
+            )
+            assertTrue(
+                value.qualifiedName === dev.inmo.micro_utils.ksp.sealed.generator.test.Test.subtypes().elementAt(index).qualifiedName
+            )
+        }
+    }
+}

ksp/sealed/src/commonMain/kotlin/GenerateSealedTypesWorkaround.kt

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.ksp.sealed
+
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.CLASS)
+annotation class GenerateSealedTypesWorkaround(
+    val prefix: String = "",
+    val includeNonSealedSubTypes: Boolean = false,
+) {
+    @Retention(AnnotationRetention.BINARY)
+    @Target(AnnotationTarget.CLASS)
+    annotation class Order(val order: Int)
+    @Retention(AnnotationRetention.BINARY)
+    @Target(AnnotationTarget.CLASS)
+    annotation class Exclude
+}

ksp/sealed/src/commonMain/kotlin/GenerateSealedWorkaround.kt

@@ -4,7 +4,7 @@ package dev.inmo.micro_utils.ksp.sealed
 @Target(AnnotationTarget.CLASS)
 annotation class GenerateSealedWorkaround(
     val prefix: String = "",
-    val includeNonSealedSubTypes: Boolean = false
+    val includeNonSealedSubTypes: Boolean = false,
 ) {
     @Retention(AnnotationRetention.BINARY)
     @Target(AnnotationTarget.CLASS)

ksp/variations/build.gradle

@@ -0,0 +1,7 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"

ksp/variations/generator/build.gradle

@@ -0,0 +1,22 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+}
+
+apply from: "$publish_jvm"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation libs.kt.stdlib
+    api project(":micro_utils.ksp.generator")
+    api project(":micro_utils.ksp.variations")
+    api libs.kotlin.poet
+    api libs.ksp
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

ksp/variations/generator/src/main/kotlin/Processor.kt

@@ -0,0 +1,243 @@
+package dev.inmo.micro_utils.ksp.variations.generator
+
+import com.google.devtools.ksp.KSTypeNotPresentException
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getAnnotationsByType
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.*
+import com.squareup.kotlinpoet.*
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.ksp.toAnnotationSpec
+import com.squareup.kotlinpoet.ksp.toClassName
+import com.squareup.kotlinpoet.ksp.toKModifier
+import com.squareup.kotlinpoet.ksp.toTypeName
+import dev.inmo.micro_ksp.generator.convertToClassName
+import dev.inmo.micro_ksp.generator.convertToClassNames
+import dev.inmo.micro_ksp.generator.findSubClasses
+import dev.inmo.micro_ksp.generator.writeFile
+import dev.inmo.micro_utils.ksp.variations.GenerateVariations
+import dev.inmo.micro_utils.ksp.variations.GenerationVariant
+import kotlin.math.pow
+
+class Processor(
+    private val codeGenerator: CodeGenerator
+) : SymbolProcessor {
+    private fun KSClassDeclaration.findSealedConnection(potentialSealedParent: KSClassDeclaration): Boolean {
+        val targetClassname = potentialSealedParent.qualifiedName ?.asString()
+        return superTypes.any {
+            val itAsDeclaration = it.resolve().declaration as? KSClassDeclaration ?: return@any false
+            targetClassname == (itAsDeclaration.qualifiedName ?.asString()) || (itAsDeclaration.getSealedSubclasses().any() && itAsDeclaration.findSealedConnection(potentialSealedParent))
+        }
+    }
+
+    private fun KSClassDeclaration.resolveSubclasses(
+        searchIn: Sequence<KSAnnotated>,
+        allowNonSealed: Boolean
+    ): Sequence<KSClassDeclaration> {
+        return findSubClasses(searchIn).let {
+            if (allowNonSealed) {
+                it
+            } else {
+                it.filter {
+                    it.findSealedConnection(this)
+                }
+            }
+        }
+    }
+
+    @OptIn(KspExperimental::class)
+    private fun FileSpec.Builder.generateVariations(
+        ksFunctionDeclaration: KSFunctionDeclaration,
+        resolver: Resolver
+    ) {
+        val annotation = ksFunctionDeclaration.getAnnotationsByType(GenerateVariations::class).first()
+        val variations: List<Pair<List<GenerationVariant>, KSValueParameter>> = ksFunctionDeclaration.parameters.mapNotNull {
+            val variationAnnotations = it.getAnnotationsByType(GenerationVariant::class).toList()
+            variationAnnotations to it
+        }
+        val accumulatedGenerations = mutableSetOf<Pair<FunSpec, Map<String, String>>>()
+        val baseFunctionParameters = ksFunctionDeclaration.parameters.mapNotNull {
+            ParameterSpec
+                .builder(
+                    it.name ?.asString() ?: return@mapNotNull null,
+                    it.type.toTypeName(),
+                )
+                .apply {
+                    if (it.isCrossInline) {
+                        addModifiers(KModifier.CROSSINLINE)
+                    }
+                    if (it.isVal) {
+                        addModifiers(KModifier.VALUE)
+                    }
+                    if (it.isNoInline) {
+                        addModifiers(KModifier.NOINLINE)
+                    }
+                    if (it.isVararg) {
+                        addModifiers(KModifier.VARARG)
+                    }
+                    it.annotations.forEach {
+                        if (it.shortName.asString() == GenerationVariant::class.simpleName) return@forEach
+
+                        addAnnotation(it.toAnnotationSpec(omitDefaultValues = false))
+                    }
+                }
+                .build() to it.hasDefault
+        }
+        val baseFunctionFunSpecs = mutableListOf<Pair<FunSpec, Map<String, String>>>()
+        let {
+            var defaultParametersIndicator = 0u
+            val maxIndicator = baseFunctionParameters.filter { it.second }.foldIndexed(0u) { index, acc, _ ->
+                2.0.pow(index).toUInt() + acc
+            }
+            while (defaultParametersIndicator <= maxIndicator) {
+                var currentDefaultParameterIndex = 0u
+                val baseFunctionDefaults = mutableMapOf<String, String>()
+                val funSpec = FunSpec.builder(ksFunctionDeclaration.simpleName.asString()).apply {
+                    modifiers.addAll(ksFunctionDeclaration.modifiers.mapNotNull { it.toKModifier() })
+                    ksFunctionDeclaration.annotations.forEach {
+                        if (it.shortName.asString() == GenerateVariations::class.simpleName) return@forEach
+
+                        addAnnotation(it.toAnnotationSpec(omitDefaultValues = false))
+                    }
+                    ksFunctionDeclaration.extensionReceiver ?.let {
+                        receiver(it.toTypeName())
+                    }
+                    ksFunctionDeclaration.returnType ?.let {
+                        returns(it.toTypeName())
+                    }
+                }
+                baseFunctionParameters.forEach { (parameter, hasDefault) ->
+                    if (hasDefault) {
+                        val shouldBeIncluded = (2.0.pow(currentDefaultParameterIndex.toInt()).toUInt()).and(defaultParametersIndicator) > 0u
+                        currentDefaultParameterIndex++
+
+                        if (!shouldBeIncluded) {
+                            return@forEach
+                        }
+                    }
+                    funSpec.addParameter(parameter)
+                    val name = parameter.name
+                    val defaultValueString = if (parameter.modifiers.contains(KModifier.VARARG)) {
+                        "*$name"
+                    } else {
+                        "$name"
+                    }
+                    baseFunctionDefaults[parameter.name] = defaultValueString
+                }
+                baseFunctionFunSpecs.add(
+                    funSpec.build() to baseFunctionDefaults.toMap()
+                )
+                defaultParametersIndicator++
+            }
+        }
+        variations.forEach { (variations, parameter) ->
+            (baseFunctionFunSpecs + accumulatedGenerations).forEach { (accumulatedGeneration, baseDefaults) ->
+                if ((parameter.name ?.asString() ?: "this") !in baseDefaults.keys) {
+                    return@forEach
+                }
+                variations.forEach { variation ->
+                    val defaults = mutableMapOf<String, String>()
+                    accumulatedGenerations.add(
+                        FunSpec.builder(accumulatedGeneration.name).apply {
+                            modifiers.addAll(accumulatedGeneration.modifiers)
+                            accumulatedGeneration.annotations.forEach {
+                                addAnnotation(it)
+                            }
+                            accumulatedGeneration.receiverType ?.let {
+                                receiver(it)
+                            }
+                            returns(accumulatedGeneration.returnType)
+                            accumulatedGeneration.parameters.forEach {
+                                val actualName = if (variation.argName.isEmpty()) it.name else variation.argName
+                                parameters.add(
+                                    (if (it.name == (parameter.name ?.asString() ?: "this")) {
+                                        val type = convertToClassName { variation.type }
+                                        val genericTypes = convertToClassNames { variation.genericTypes.toList()  }
+                                        ParameterSpec
+                                            .builder(
+                                                actualName,
+                                                if (genericTypes.isEmpty()) {
+                                                    type
+                                                } else {
+                                                    type.parameterizedBy(
+                                                        *genericTypes.toTypedArray()
+                                                    )
+                                                }
+                                            )
+                                            .apply {
+                                                addModifiers(it.modifiers)
+                                                val defaultValueString = """
+                                                    with(${actualName}) {${
+                                                            if (it.modifiers.contains(KModifier.VARARG)) {
+                                                                "map { it.${variation.conversion} }.toTypedArray()"
+                                                            } else {
+                                                                "${variation.conversion}"
+                                                            }
+                                                    }}
+                                                """.trimIndent()
+                                                defaults[it.name] = defaultValueString
+                                            }
+                                    } else {
+                                        it.toBuilder().apply {
+                                            defaults[it.name] = it.name
+                                        }
+                                    })
+                                        .apply {
+                                            it.annotations.forEach {
+                                                addAnnotation(it)
+                                            }
+                                        }
+                                        .build()
+                                )
+                            }
+                            val parameters = accumulatedGeneration.parameters.joinToString(", ") {
+                                val itName = it.name
+                                """
+                                    $itName = ${defaults[itName] ?: baseDefaults[itName] ?: itName}
+                                """.trimIndent()
+                            }
+                            addCode(
+                                """
+                                    return ${ksFunctionDeclaration.simpleName.asString()}(
+                                        $parameters
+                                    )
+                                """.trimIndent()
+                            )
+                        }.build() to defaults.toMap()
+                    )
+                }
+            }
+        }
+        accumulatedGenerations.forEach {
+            addFunction(it.first)
+        }
+    }
+
+    @OptIn(KspExperimental::class)
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        (resolver.getSymbolsWithAnnotation(GenerateVariations::class.qualifiedName!!)).filterIsInstance<KSFunctionDeclaration>().forEach {
+            val prefix = (it.getAnnotationsByType(GenerateVariations::class)).firstOrNull() ?.prefix ?.takeIf {
+                it.isNotEmpty()
+            } ?: it.simpleName.asString().replaceFirst(it.simpleName.asString(), "")
+            it.writeFile(prefix = prefix, suffix = "GeneratedVariation") {
+                FileSpec.builder(
+                    it.packageName.asString(),
+                    "${it.simpleName.getShortName().let { it.replaceFirst(it.first().toString(), it.first().uppercase()) }}GeneratedVariation"
+                ).apply {
+                    addFileComment(
+                        """
+                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+                        TO REGENERATE IT JUST DELETE FILE
+                        ORIGINAL FILE: ${it.containingFile ?.fileName}
+                        """.trimIndent()
+                    )
+                    generateVariations(it, resolver)
+                }.build()
+            }
+        }
+
+        return emptyList()
+    }
+}

ksp/variations/generator/src/main/kotlin/Provider.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.ksp.variations.generator
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+class Provider : SymbolProcessorProvider {
+    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor = Processor(
+        environment.codeGenerator
+    )
+}

ksp/variations/generator/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -0,0 +1 @@
+dev.inmo.micro_utils.ksp.variations.generator.Provider

ksp/variations/generator/test/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    id "com.google.devtools.ksp"
+}
+
+ext.do_publish = false
+
+apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64Project"
+
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation libs.kt.stdlib
+                api project(":micro_utils.ksp.variations")
+            }
+        }
+    }
+}
+
+
+dependencies {
+    add("kspCommonMainMetadata", project(":micro_utils.ksp.variations.generator"))
+}
+
+ksp {
+}

ksp/variations/generator/test/src/commonMain/kotlin/Sample2GeneratedVariation.kt

@@ -0,0 +1,61 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: SampleFun.kt
+package dev.inmo.micro_utils.ksp.variations.generator.test
+
+import kotlin.Boolean
+import kotlin.Int
+import kotlin.String
+import kotlin.Unit
+
+public suspend fun SimpleType.sample2(arg12: Int): Unit = sample2(
+    arg1 = with(arg12) {toString()}
+)
+
+public suspend fun SimpleType.sample2(arg12: Int, arg2: Int): Unit = sample2(
+    arg1 = with(arg12) {toString()}, arg2 = arg2
+)
+
+public suspend fun SimpleType.sample2(arg12: Int, arg3: Boolean): Unit = sample2(
+    arg1 = with(arg12) {toString()}, arg3 = arg3
+)
+
+public suspend fun SimpleType.sample2(
+  arg12: Int,
+  arg2: Int,
+  arg3: Boolean,
+): Unit = sample2(
+    arg1 = with(arg12) {toString()}, arg2 = arg2, arg3 = arg3
+)
+
+public suspend fun SimpleType.sample2(arg22: String): Unit = sample2(
+    arg2 = with(arg22) {toInt()}
+)
+
+public suspend fun SimpleType.sample2(arg1: String, arg22: String): Unit = sample2(
+    arg1 = arg1, arg2 = with(arg22) {toInt()}
+)
+
+public suspend fun SimpleType.sample2(arg22: String, arg3: Boolean): Unit = sample2(
+    arg2 = with(arg22) {toInt()}, arg3 = arg3
+)
+
+public suspend fun SimpleType.sample2(
+  arg1: String,
+  arg22: String,
+  arg3: Boolean,
+): Unit = sample2(
+    arg1 = arg1, arg2 = with(arg22) {toInt()}, arg3 = arg3
+)
+
+public suspend fun SimpleType.sample2(arg12: Int, arg22: String): Unit = sample2(
+    arg12 = arg12, arg2 = with(arg22) {toInt()}
+)
+
+public suspend fun SimpleType.sample2(
+  arg12: Int,
+  arg22: String,
+  arg3: Boolean,
+): Unit = sample2(
+    arg12 = arg12, arg2 = with(arg22) {toInt()}, arg3 = arg3
+)

ksp/variations/generator/test/src/commonMain/kotlin/SampleFun.kt

@@ -0,0 +1,52 @@
+package dev.inmo.micro_utils.ksp.variations.generator.test
+
+import dev.inmo.micro_utils.ksp.variations.GenerateVariations
+import dev.inmo.micro_utils.ksp.variations.GenerationVariant
+
+data class SimpleType(
+    val value: String
+)
+
+data class GenericType<T>(
+    val value: T
+)
+
+@GenerateVariations
+fun sample(
+    @GenerationVariant(
+        SimpleType::class,
+        "value",
+    )
+    @GenerationVariant(
+        GenericType::class,
+        "value.toString()",
+        genericTypes = arrayOf(Int::class)
+    )
+    example: String = "12"
+) = println(example)
+
+@GenerateVariations
+fun sampleVararg(
+    @GenerationVariant(
+        SimpleType::class,
+        "value",
+    )
+    vararg example: String = arrayOf("12")
+) = println(example.joinToString())
+
+@GenerateVariations
+suspend fun SimpleType.sample2(
+    @GenerationVariant(
+        Int::class,
+        "toString()",
+        "arg12",
+    )
+    arg1: String = "1",
+    @GenerationVariant(
+        String::class,
+        "toInt()",
+        "arg22",
+    )
+    arg2: Int = 2,
+    arg3: Boolean = false
+) = println(arg1)

ksp/variations/generator/test/src/commonMain/kotlin/SampleGeneratedVariation.kt

@@ -0,0 +1,15 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: SampleFun.kt
+package dev.inmo.micro_utils.ksp.variations.generator.test
+
+import kotlin.Int
+import kotlin.Unit
+
+public fun sample(example: SimpleType): Unit = sample(
+    example = with(example) {value}
+)
+
+public fun sample(example: GenericType<Int>): Unit = sample(
+    example = with(example) {value.toString()}
+)

ksp/variations/generator/test/src/commonMain/kotlin/SampleVarargGeneratedVariation.kt

@@ -0,0 +1,10 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: SampleFun.kt
+package dev.inmo.micro_utils.ksp.variations.generator.test
+
+import kotlin.Unit
+
+public fun sampleVararg(vararg example: SimpleType): Unit = sampleVararg(
+    example = with(example) {map { it.value }.toTypedArray()}
+)

ksp/variations/src/commonMain/kotlin/GenerateVariations.kt

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.ksp.variations
+
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.FUNCTION)
+annotation class GenerateVariations(
+    val prefix: String = ""
+)

ksp/variations/src/commonMain/kotlin/GenerationVariant.kt

@@ -0,0 +1,18 @@
+package dev.inmo.micro_utils.ksp.variations
+
+import kotlin.reflect.KClass
+
+/**
+ * @param argName New argument name. Default - empty - means "use default arg name"
+ * @param type Qualified class name, like "dev.inmo.micro_utils.ksp.variants.GenerationVariant"
+ * @param conversion Conversion string with `this`
+ */
+@Retention(AnnotationRetention.BINARY)
+@Repeatable
+@Target(AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.VALUE_PARAMETER)
+annotation class GenerationVariant(
+    val type: KClass<*>,
+    val conversion: String,
+    val argName: String = "",
+    vararg val genericTypes: KClass<*>
+)

ktor/client/src/jsMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualTemporalUpload.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
 import io.ktor.client.content.*
@@ -27,7 +27,7 @@ suspend fun tempUpload(
     val request = XMLHttpRequest()
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchLoggingDropExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {

ktor/client/src/jsMain/kotlin/dev/inmo/micro_utils/ktor/client/ActualUniUpload.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import io.ktor.client.HttpClient
 import io.ktor.client.content.*
 import io.ktor.http.Headers
@@ -66,7 +66,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     }
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchLoggingDropExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {

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

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.ktor.server
 import com.benasher44.uuid.uuid4
 import dev.inmo.micro_utils.common.FileName
 import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.ktor.common.DefaultTemporalFilesSubPath
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.ktor.server.configurators.ApplicationRoutingConfigurator
@@ -44,7 +44,7 @@ class TemporalFilesRoutingConfigurator(
                     filesMap: MutableMap<TemporalFileId, MPPFile>,
                     filesMutex: Mutex,
                     onNewFileFlow: Flow<TemporalFileId>
-                ): Job = scope.launchSafelyWithoutExceptions {
+                ): Job = scope.launchLoggingDropExceptions {
                     while (currentCoroutineContext().isActive) {
                         val filesWithCreationInfo = filesMap.mapNotNull { (fileId, file) ->
                             fileId to ((Files.getAttribute(file.toPath(), "creationTime") as? FileTime) ?.toMillis() ?: return@mapNotNull null)

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/Pagination.kt

@@ -40,6 +40,8 @@ fun Pagination.intersect(
 inline val Pagination.isFirstPage
     get() = page == 0
 
+fun Pagination.firstPage() = if (isFirstPage) this else SimplePagination(0, size)
+
 /**
  * First number in index of objects. It can be used as offset for databases or other data sources
  */

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/PaginationResult.kt

@@ -32,7 +32,7 @@ data class PaginationResult<T>(
         page: Int,
         results: List<T>,
         pagesNumber: Int,
-        size: Int
+        size: Int = results.size
     ) : this(
         page,
         size,

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/SimplePagination.kt

@@ -26,6 +26,16 @@ inline fun Pagination.nextPage() =
         size
     )
 
+/**
+ * This method DO NOT check [Pagination.page] of receiver. Returns pagination for previous page
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun Pagination.previousPage() =
+    SimplePagination(
+        page - 1,
+        size
+    )
+
 /**
  * @param page Current page number
  * @param size Current page size

pagination/compose/build.gradle

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

pagination/compose/src/commonMain/kotlin/InfinityPagedComponent.kt

@@ -0,0 +1,117 @@
+package dev.inmo.micro_utils.pagination.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import dev.inmo.micro_utils.pagination.*
+
+/**
+ * Context for managing infinite pagination in a Compose UI.
+ *
+ * @param T The type of the data being paginated.
+ * @property iterationState Holds the current pagination state and iteration count.
+ * @property dataState Stores the loaded data, initially null.
+ * @constructor Internal constructor to initialize pagination.
+ * @param page Initial page number.
+ * @param size Number of items per page.
+ */
+class InfinityPagedComponentContext<T> internal constructor(
+    page: Int,
+    size: Int
+) {
+    internal val startPage = SimplePagination(page, size)
+    internal val currentlyLoadingPage = SpecialMutableStateFlow<Pagination?>(startPage)
+    internal val latestLoadedPage = SpecialMutableStateFlow<PaginationResult<T>?>(null)
+    internal val dataState = SpecialMutableStateFlow<List<T>?>(null)
+
+    /**
+     * Loads the next page of data. If the current page is the last one, the function returns early.
+     */
+    fun loadNext() {
+        if (latestLoadedPage.value ?.isLastPage == true) return
+        if (currentlyLoadingPage.value != null) return // Data loading has been inited but not loaded yet
+
+        currentlyLoadingPage.value = latestLoadedPage.value ?.nextPage() ?: startPage
+    }
+
+    /**
+     * Reloads the pagination from the first page, clearing previously loaded data.
+     */
+    fun reload() {
+        latestLoadedPage.value = null
+        currentlyLoadingPage.value = null
+        loadNext()
+    }
+}
+
+/**
+ * Composable function for managing an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param page Initial page number.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+internal fun <T> InfinityPagedComponent(
+    page: Int,
+    size: Int,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    val context = remember { InfinityPagedComponentContext<T>(page, size) }
+
+    val currentlyLoadingState = context.currentlyLoadingPage.collectAsState()
+    LaunchedEffect(currentlyLoadingState.value) {
+        val paginationResult = loader(context, currentlyLoadingState.value ?: return@LaunchedEffect)
+        context.latestLoadedPage.value = paginationResult
+        context.currentlyLoadingPage.value = null
+
+        context.dataState.value = (context.dataState.value ?: emptyList()) + paginationResult.results
+    }
+
+    val dataState = context.dataState.collectAsState()
+    context.block(dataState.value)
+}
+
+/**
+ * Overloaded composable function for an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param pageInfo Initial pagination information.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+fun <T> InfinityPagedComponent(
+    pageInfo: Pagination,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    InfinityPagedComponent(
+        pageInfo.page,
+        pageInfo.size,
+        loader,
+        block
+    )
+}
+
+/**
+ * Overloaded composable function for an infinitely paged component.
+ *
+ * @param T The type of the paginated data.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data. When data is in loading state, block will
+ * receive null as `it` parameter
+ */
+@Composable
+fun <T> InfinityPagedComponent(
+    size: Int,
+    loader: suspend InfinityPagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable InfinityPagedComponentContext<T>.(List<T>?) -> Unit
+) {
+    InfinityPagedComponent(0, size, loader, block)
+}

pagination/compose/src/commonMain/kotlin/PagedComponent.kt

@@ -0,0 +1,126 @@
+package dev.inmo.micro_utils.pagination.compose
+
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import dev.inmo.micro_utils.pagination.*
+
+/**
+ * Context for managing paginated data in a Compose UI.
+ *
+ * @param T The type of data being paginated.
+ * @property iterationState Holds the current pagination state and iteration count.
+ * @property dataOptional Stores the optional preloaded pagination result.
+ * @property dataState Stores the current pagination result.
+ * @constructor Internal constructor for setting up pagination.
+ * @param preset Optional preset pagination result.
+ * @param initialPage Initial page number.
+ * @param size Number of items per page.
+ */
+class PagedComponentContext<T> internal constructor(
+    initialPage: Int,
+    size: Int
+) {
+    internal val startPage = SimplePagination(initialPage, size)
+    internal val currentlyLoadingPageState = SpecialMutableStateFlow<Pagination?>(startPage)
+    internal val latestLoadedPage = SpecialMutableStateFlow<PaginationResult<T>?>(null)
+
+    /**
+     * Loads the next page of data. If the last page is reached, this function returns early.
+     */
+    fun loadNext() {
+        when {
+            currentlyLoadingPageState.value != null -> return
+            latestLoadedPage.value ?.isLastPage == true -> return
+            else -> currentlyLoadingPageState.value = (latestLoadedPage.value ?.nextPage()) ?: startPage
+        }
+    }
+
+    /**
+     * Loads the previous page of data if available.
+     */
+    fun loadPrevious() {
+        when {
+            currentlyLoadingPageState.value != null -> return
+            latestLoadedPage.value ?.isFirstPage == true -> return
+            else -> currentlyLoadingPageState.value = (latestLoadedPage.value ?.previousPage()) ?: startPage
+        }
+    }
+
+    /**
+     * Reloads the current page, refreshing the data.
+     */
+    fun reload() {
+        currentlyLoadingPageState.value = latestLoadedPage.value
+    }
+}
+
+/**
+ * Composable function for paginated data displaying in a Compose UI.
+ *
+ * @param T The type of paginated data.
+ * @param preload Optional preloaded pagination result.
+ * @param initialPage Initial page number.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+internal fun <T> PagedComponent(
+    initialPage: Int,
+    size: Int,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    val context = remember { PagedComponentContext<T>(initialPage, size) }
+
+    val currentlyLoadingState = context.currentlyLoadingPageState.collectAsState()
+    LaunchedEffect(currentlyLoadingState.value) {
+        val paginationResult = loader(context, currentlyLoadingState.value ?: return@LaunchedEffect)
+        context.latestLoadedPage.value = paginationResult
+        context.currentlyLoadingPageState.value = null
+    }
+
+    val pageState = context.latestLoadedPage.collectAsState()
+    pageState.value ?.let {
+        context.block(it)
+    }
+}
+
+/**
+ * Overloaded composable function for paginated components with pagination info.
+ *
+ * @param T The type of paginated data.
+ * @param pageInfo Initial pagination information.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+fun <T> PagedComponent(
+    pageInfo: Pagination,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    PagedComponent(
+        pageInfo.page,
+        pageInfo.size,
+        loader,
+        block
+    )
+}
+
+/**
+ * Overloaded composable function for paginated components with only a size parameter.
+ *
+ * @param T The type of paginated data.
+ * @param size Number of items per page.
+ * @param loader Suspended function that loads paginated data.
+ * @param block Composable function that renders the UI with the loaded data.
+ */
+@Composable
+fun <T> PagedComponent(
+    size: Int,
+    loader: suspend PagedComponentContext<T>.(Pagination) -> PaginationResult<T>,
+    block: @Composable PagedComponentContext<T>.(PaginationResult<T>) -> Unit
+) {
+    PagedComponent(0, size, loader, block)
+}

pagination/compose/src/jvmTest/kotlin/InfinityPagedComponentTests.kt

@@ -0,0 +1,51 @@
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.compose.InfinityPagedComponent
+import dev.inmo.micro_utils.pagination.compose.PagedComponent
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+
+class InfinityPagedComponentTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun testSimpleLoad() = runComposeUiTest {
+        var expectedList = listOf<Int>()
+        setContent {
+            InfinityPagedComponent<Int>(
+                size = 1,
+                loader = {
+                    PaginationResult(
+                        page = it.page,
+                        size = it.size,
+                        results = (it.firstIndex .. it.lastIndex).toList(),
+                        objectsNumber = 3
+                    ).also {
+                        expectedList += it.results
+                    }
+                }
+            ) {
+                if (it == null) {
+                    assertEquals(0, this.currentlyLoadingPage.value ?.page)
+                } else {
+                    assertEquals(expectedList, it)
+                }
+
+                LaunchedEffect(it ?.size) {
+                    loadNext()
+                }
+            }
+        }
+
+        waitForIdle()
+
+        assertContentEquals(
+            listOf(0, 1, 2),
+            expectedList
+        )
+    }
+}

pagination/compose/src/jvmTest/kotlin/PagedComponentTests.kt

@@ -0,0 +1,64 @@
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.compose.PagedComponent
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class PagedComponentTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun testSimpleLoad() = runComposeUiTest {
+        var expectedPage = PaginationResult(
+            page = 0,
+            size = 1,
+            results = listOf(0),
+            objectsNumber = 3
+        )
+        var previousPage = expectedPage
+        setContent {
+            PagedComponent<Int>(
+                initialPage = 0,
+                size = 1,
+                loader = {
+                    previousPage = expectedPage
+                    expectedPage = PaginationResult(
+                        page = it.page,
+                        size = it.size,
+                        results = (it.firstIndex .. it.lastIndex).toList(),
+                        objectsNumber = 3
+                    )
+                    expectedPage
+                }
+            ) {
+                assertEquals(expectedPage, it)
+                assertEquals(expectedPage.results, it.results)
+
+                if (it.isLastPage || it.page < previousPage.page) {
+                    if (it.isFirstPage) {
+                        // do nothing - end of test
+                    } else {
+                        loadPrevious()
+                    }
+                } else {
+                    loadNext()
+                }
+            }
+        }
+
+        waitForIdle()
+
+        assertEquals(
+            PaginationResult(
+                page = 0,
+                size = 1,
+                results = listOf(0),
+                objectsNumber = 3
+            ),
+            expectedPage
+        )
+    }
+}

pagination/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/pagination/QueryExtensions.kt

@@ -2,19 +2,19 @@ package dev.inmo.micro_utils.pagination
 
 import org.jetbrains.exposed.sql.*
 
-fun Query.paginate(with: Pagination, orderBy: Pair<Expression<*>, SortOrder>? = null) = limit(
-    with.size,
-    with.firstIndex.toLong()
-).let {
-    if (orderBy != null) {
-        it.orderBy(
-            orderBy.first,
-            orderBy.second
-        )
-    } else {
-        it
+fun Query.paginate(with: Pagination, orderBy: Pair<Expression<*>, SortOrder>? = null) =
+    limit(with.size)
+    .offset(with.firstIndex.toLong())
+    .let {
+        if (orderBy != null) {
+            it.orderBy(
+                orderBy.first,
+                orderBy.second
+            )
+        } else {
+            it
+        }
     }
-}
 
 fun Query.paginate(with: Pagination, orderBy: Expression<*>?, reversed: Boolean = false) = paginate(
     with,

renovate.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
-    "config:base"
+    "config:recommended"
   ]
 }

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullCRUDCacheRepo.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
@@ -17,7 +17,7 @@ import kotlinx.coroutines.Dispatchers
 open class FullReadCRUDCacheRepo<ObjectType, IdType>(
     protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
     protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
+    protected open val locker: SmartRWLocker = SmartRWLocker(),
     protected open val idGetter: (ObjectType) -> IdType
 ) : ReadCRUDRepo<ObjectType, IdType>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
@@ -95,11 +95,11 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
 
 open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
-    kvCache: KeyValueRepo<IdType, ObjectType>,
+    override val kvCache: KeyValueRepo<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
-    idGetter: (ObjectType) -> IdType
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val idGetter: (ObjectType) -> IdType
 ) : FullReadCRUDCacheRepo<ObjectType, IdType>(
     parentRepo,
     kvCache,
@@ -116,7 +116,7 @@ open class FullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     CRUDRepo<ObjectType, IdType, InputValueType> {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValueCacheRepo.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
@@ -17,7 +17,7 @@ import kotlinx.coroutines.flow.*
 open class FullReadKeyValueCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
     protected open val kvCache: KeyValueRepo<Key, Value>,
-    protected val locker: SmartRWLocker = SmartRWLocker()
+    protected open val locker: SmartRWLocker = SmartRWLocker()
 ) : ReadKeyValueRepo<Key, Value>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
         action: KeyValueRepo<Key, Value>.() -> Optional<T>,
@@ -127,10 +127,10 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.caching(
 
 open class FullKeyValueCacheRepo<Key,Value>(
     override val parentRepo: KeyValueRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, Value>,
+    override val kvCache: KeyValueRepo<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : //FullWriteKeyValueCacheRepo<Key,Value>(parentRepo, kvCache, scope),
     KeyValueRepo<Key,Value>,
     WriteKeyValueRepo<Key,Value> by parentRepo,
@@ -141,7 +141,7 @@ open class FullKeyValueCacheRepo<Key,Value>(
 ) {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/FullKeyValuesCacheRepo.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.cache.full
 
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
@@ -18,7 +18,7 @@ import kotlinx.coroutines.flow.*
 open class FullReadKeyValuesCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
     protected open val kvCache: KeyValueRepo<Key, List<Value>>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
+    protected open val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValuesRepo<Key, Value>, FullCacheRepo {
     protected suspend inline fun <T> doOrTakeAndActualize(
         action: KeyValueRepo<Key, List<Value>>.() -> Optional<T>,
@@ -201,16 +201,16 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.caching(
 
 open class FullKeyValuesCacheRepo<Key,Value>(
     override val parentRepo: KeyValuesRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, List<Value>>,
+    override val kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : KeyValuesRepo<Key, Value>,
     FullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
     WriteKeyValuesRepo<Key, Value> by parentRepo {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullCRUDCacheRepo.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.cache.full.direct
 
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
@@ -17,7 +17,7 @@ import kotlinx.coroutines.Dispatchers
 open class DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
     protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
     protected open val kvCache: KeyValueRepo<IdType, ObjectType>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
+    protected open val locker: SmartRWLocker = SmartRWLocker(),
     protected open val idGetter: (ObjectType) -> IdType
 ) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
     protected open suspend fun actualizeAll() {
@@ -61,10 +61,10 @@ fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
 
 open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
-    kvCache: KeyValueRepo<IdType, ObjectType>,
+    override val kvCache: KeyValueRepo<IdType, ObjectType>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
     idGetter: (ObjectType) -> IdType
 ) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
     parentRepo,
@@ -82,7 +82,7 @@ open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     CRUDRepo<ObjectType, IdType, InputValueType> {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValueCacheRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.cache.full.direct
 
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.Pagination
@@ -20,7 +20,7 @@ import kotlinx.coroutines.flow.onEach
 open class DirectFullReadKeyValueCacheRepo<Key, Value>(
     protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
     protected open val kvCache: KeyValueRepo<Key, Value>,
-    protected val locker: SmartRWLocker = SmartRWLocker()
+    protected open val locker: SmartRWLocker = SmartRWLocker()
 ) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
     protected open suspend fun actualizeAll() {
         kvCache.actualizeAll(parentRepo, locker)
@@ -102,10 +102,10 @@ fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
 
 open class DirectFullKeyValueCacheRepo<Key, Value>(
     override val parentRepo: KeyValueRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, Value>,
+    override val kvCache: KeyValueRepo<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : DirectFullCacheRepo,
     KeyValueRepo<Key, Value> ,
     WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
@@ -117,7 +117,7 @@ open class DirectFullKeyValueCacheRepo<Key, Value>(
     DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/full/direct/DirectFullKeyValuesCacheRepo.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.cache.full.direct
 
 import dev.inmo.micro_utils.common.*
 import dev.inmo.micro_utils.coroutines.SmartRWLocker
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.withReadAcquire
 import dev.inmo.micro_utils.coroutines.withWriteLock
 import dev.inmo.micro_utils.pagination.*
@@ -17,7 +17,7 @@ import kotlinx.coroutines.flow.*
 open class DirectFullReadKeyValuesCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
     protected open val kvCache: KeyValueRepo<Key, List<Value>>,
-    protected val locker: SmartRWLocker = SmartRWLocker(),
+    protected open val locker: SmartRWLocker = SmartRWLocker(),
 ) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
     protected open suspend fun actualizeKey(k: Key) {
         kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
@@ -136,16 +136,16 @@ fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
 
 open class DirectFullKeyValuesCacheRepo<Key,Value>(
     override val parentRepo: KeyValuesRepo<Key, Value>,
-    kvCache: KeyValueRepo<Key, List<Value>>,
+    override val kvCache: KeyValueRepo<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     skipStartInvalidate: Boolean = false,
-    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    override val locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
 ) : KeyValuesRepo<Key, Value>,
     DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
     WriteKeyValuesRepo<Key, Value> by parentRepo {
     init {
         if (!skipStartInvalidate) {
-            scope.launchSafelyWithoutExceptions {
+            scope.launchLoggingDropExceptions {
                 if (locker.writeMutex.isLocked) {
                     initialInvalidate()
                 } else {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedWriteCRUDRepo.kt

@@ -137,7 +137,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override suspend fun deleteById(ids: List<IdType>) {
         onBeforeDelete(ids)
         transaction(db = database) {
-            val deleted = deleteWhere(null, null) { selectByIds(it, ids) }
+            val deleted = deleteWhere { selectByIds(it, ids) }
             if (deleted == ids.size) {
                 ids
             } else {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/CommonExposedRepo.kt

@@ -8,8 +8,16 @@ interface CommonExposedRepo<IdType, ObjectType> : ExposedRepo {
     val selectById: ISqlExpressionBuilder.(IdType) -> Op<Boolean>
     val selectByIds: ISqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
         get() = {
-            it.foldRight<IdType, Op<Boolean>?>(null) { id, acc ->
-                acc ?.or(selectById(id)) ?: selectById(id)
-            } ?: Op.FALSE
+            if (it.isEmpty()) {
+                Op.FALSE
+            } else {
+                var op = it.firstOrNull() ?.let { selectById(it) } ?: Op.FALSE
+                var i = 1
+                while (i < it.size) {
+                    op = op.or(selectById(it[i]))
+                    i++
+                }
+                op
+            }
         }
 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/AbstractExposedKeyValuesRepo.kt

@@ -4,7 +4,6 @@ import dev.inmo.micro_utils.repos.KeyValuesRepo
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.statements.InsertStatement
 import org.jetbrains.exposed.sql.statements.UpdateBuilder
 import org.jetbrains.exposed.sql.transactions.transaction
 
@@ -57,18 +56,48 @@ abstract class AbstractExposedKeyValuesRepo<Key, Value>(
             }
         }
 
-        transaction(database) {
+        val (oldObjects, insertedResults) = transaction(database) {
+            val oldObjects = selectAll().where { selectByIds(toSet.keys.toList()) }.map { it.asKey to it.asObject }
+
             deleteWhere {
                 selectByIds(it, toSet.keys.toList())
             }
-            batchInsert(
+            val inserted = batchInsert(
                 prepreparedData,
             ) { (k, v) ->
                 insert(k, v, this)
             }.map {
                 it.asKey to it.asObject
             }
-        }.forEach { _onNewValue.emit(it) }
+            oldObjects to inserted
+        }.let {
+            val mappedFirst = it
+                .first
+                .asSequence()
+                .groupBy { it.first }
+                .mapValues { it.value.map { it.second }.toSet() }
+            val mappedSecond = it
+                .second
+                .asSequence()
+                .groupBy { it.first }
+                .mapValues { it.value.map { it.second }.toSet() }
+            mappedFirst to mappedSecond
+        }
+        val deletedResults = oldObjects.mapNotNull { (k, vs) ->
+            k to vs.filter { v ->
+                insertedResults[k] ?.contains(v) != true
+            }.ifEmpty { return@mapNotNull null }
+        }
+        deletedResults.forEach { (k, vs) ->
+            vs.forEach { v ->
+                _onValueRemoved.emit(k to v)
+            }
+        }
+        insertedResults.forEach { (k, vs) ->
+            vs.forEach { v ->
+                _onNewValue.emit(k to v)
+            }
+        }
     }
 
     override suspend fun remove(toRemove: Map<Key, List<Value>>) {

settings.gradle

@@ -11,6 +11,7 @@ String[] includes = [
     ":koin:generator:test",
     ":selector:common",
     ":pagination:common",
+    ":pagination:compose",
     ":pagination:exposed",
     ":pagination:ktor:common",
     ":pagination:ktor:server",
@@ -62,6 +63,10 @@ String[] includes = [
     ":ksp:classcasts:generator",
     ":ksp:classcasts:generator:test",
 
+    ":ksp:variations",
+    ":ksp:variations:generator",
+    ":ksp:variations:generator:test",
+
     ":dokka"
 ]