Merge pull request #460 from InsanusMokrassar/0.21.1

0.21.1

.gitignore

@@ -14,3 +14,8 @@ local.properties
 kotlin-js-store
 
 publishing.sh
+
+local.*
+local/
+
+.kotlin/

CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 0.21.1
+
+* `KSP`:
+    * Module has been initialized
+    * `Generator`:
+        * Module has been initialized
+    * `Sealed`:
+        * Module has been initialized
+
+## 0.21.0
+
+**THIS UPDATE CONTAINS BREAKING CHANGES IN `safely*`-ORIENTED FUNCTIONS**
+
+* `Coroutines`:
+    * **All `safely` functions lost their `supervisorScope` in favor to wrapping `runCatching`**
+        * `runCatchingSafely` is the main handling function of all `safely` functions
+        * `launchSafely*` and `asyncSafely*` blocks lost `CoroutineScope` as their receiver
+
+## 0.20.52
+
+* `Coroutines`:
+    * Small rework of weak jobs: add `WeakScope` factory, rename old weal extensions and add kdocs
+
+## 0.20.51
+
+* `Versions`:
+    * `Android Fragment`: `1.7.0` -> `1.7.1`
+* `Pagination`:
+    * Add `Pagination.nextPageIfTrue` and `Pagination.thisPageIftrue` extensions to get the page according to condition
+    pass status
+    * Add `PaginationResult.nextPageIfNotEmptyOrLastPage` and `PaginationResult.thisPageIfNotEmptyOrLastPage`
+    * Change all `doForAll` and `getAll` extensions fo pagination to work basing on `nextPageIfNotEmptyOrLastPage` and
+    `thisPageIfNotEmptyOrLastPage`
+
+## 0.20.50
+
+* `Versions`:
+    * `Coroutines`: `1.8.0` -> `1.8.1`
+    * `KSLog`: `1.3.3` -> `1.3.4`
+    * `Exposed`: `0.50.0` -> `0.50.1`
+    * `Ktor`: `2.3.10` -> `2.3.11`
+* A lot of inline functions became common functions due to inline with only noinline callbacks in arguments leads to
+low performance
+* `Coroutines`:
+    * `SmartMutex`, `SmartSemaphore` and `SmartRWLocker` as their user changed their state flow to `SpecialMutableStateFlow`
+
+## 0.20.49
+
+* `Repos`:
+    * `Common`:
+        * All `Repo`s get `diff` extensions
+        * `KeyValueRepo` and `KeyValuesRepo` get `applyDiff` extension
+        * Add new extensions `on*` flows for crud repos
+
+## 0.20.48
+
+* `Versions`:
+    * `Android Core KTX`: `1.13.0` -> `1.13.1`
+    * `AndroidX Fragment`: `1.6.2` -> `1.7.0`
+
+## 0.20.47
+
+* `Versions`:
+    * `Exposed`: `0.49.0` -> `0.50.0`
+
+## 0.20.46
+
+* `Common`:
+    * Now this repo depends on `klock`
+    * Add new object-serializer `DateTimeSerializer` for `klock` serializer
+
+## 0.20.45
+
+* `Versions`:
+    * `Android Core KTX`: `1.12.0` -> `1.13.0`
+
 ## 0.20.44
 
 * `Versions`:

android/pickers/src/androidMain/kotlin/NumberPicker.kt

@@ -7,9 +7,6 @@ import androidx.compose.foundation.gestures.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.ContentAlpha
-import androidx.compose.material.IconButton
-import androidx.compose.material.ProvideTextStyle
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.KeyboardArrowDown
 import androidx.compose.material.icons.filled.KeyboardArrowUp
@@ -75,7 +72,7 @@ fun NumberPicker(
     }
     val coercedAnimatedOffset = animatedOffset.value % halvedNumbersColumnHeightPx
     val animatedStateValue = animatedStateValue(animatedOffset.value)
-    val disabledArrowsColor = arrowsColor.copy(alpha = ContentAlpha.disabled)
+    val disabledArrowsColor = arrowsColor.copy(alpha = 0f)
 
     val inputFieldShown = if (allowUseManualInput) {
         remember { mutableStateOf(false) }

android/pickers/src/androidMain/kotlin/SetPicker.kt

@@ -5,7 +5,6 @@ import androidx.compose.animation.core.exponentialDecay
 import androidx.compose.foundation.gestures.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
-import androidx.compose.material.ContentAlpha
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.KeyboardArrowDown
 import androidx.compose.material.icons.filled.KeyboardArrowUp
@@ -62,9 +61,7 @@ fun <T> SetPicker(
         (index - ceil(animatedOffset.value / halvedNumbersColumnHeightPx).toInt())
     }
     val coercedAnimatedOffset = animatedOffset.value % halvedNumbersColumnHeightPx
-    val boxOffset = (indexAnimatedOffset * halvedNumbersColumnHeightPx) - coercedAnimatedOffset
-    val disabledArrowsColor = arrowsColor.copy(alpha = ContentAlpha.disabled)
-    val scrollState = rememberScrollState()
+    val disabledArrowsColor = arrowsColor.copy(alpha = 0f)
 
     Column(
         modifier = modifier

common/build.gradle

@@ -8,6 +8,11 @@ apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {
+        commonMain {
+            dependencies {
+                api libs.klock
+            }
+        }
         jvmMain {
             dependencies {
                 api project(":micro_utils.coroutines")
@@ -15,23 +20,11 @@ kotlin {
         }
         androidMain {
             dependencies {
-                api project(":micro_utils.coroutines")
                 api libs.android.fragment
             }
-            dependsOn jvmMain
         }
 
-        linuxX64Main {
-            dependencies {
-                api libs.okio
-            }
-        }
-        mingwX64Main {
-            dependencies {
-                api libs.okio
-            }
-        }
-        linuxArm64Main {
+        nativeMain {
             dependencies {
                 api libs.okio
             }

common/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

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

@@ -0,0 +1,25 @@
+package dev.inmo.micro_utils.common
+
+import korlibs.time.DateTime
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * Serializes [DateTime] as its raw [DateTime.unixMillis] and deserializes in the same way
+ */
+object DateTimeSerializer : KSerializer<DateTime> {
+    override val descriptor: SerialDescriptor
+        get() = Double.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): DateTime {
+        return DateTime(decoder.decodeDouble())
+    }
+
+    override fun serialize(encoder: Encoder, value: DateTime) {
+        encoder.encodeDouble(value.unixMillis)
+    }
+}

common/src/linuxX64Main/kotlin/ActualMPPFile.kt

@@ -1,36 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import okio.FileSystem
-import okio.Path
-import okio.use
-
-actual typealias MPPFile = Path
-
-/**
- * @suppress
- */
-actual val MPPFile.filename: FileName
-    get() = FileName(toString())
-/**
- * @suppress
- */
-actual val MPPFile.filesize: Long
-    get() = FileSystem.SYSTEM.openReadOnly(this).use {
-        it.size()
-    }
-/**
- * @suppress
- */
-actual val MPPFile.bytesAllocatorSync: ByteArrayAllocator
-    get() = {
-        FileSystem.SYSTEM.read(this) {
-            readByteArray()
-        }
-    }
-/**
- * @suppress
- */
-actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
-    get() = {
-        bytesAllocatorSync()
-    }

common/src/linuxX64Main/kotlin/fixed.kt

@@ -1,25 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.cinterop.*
-import platform.posix.snprintf
-import platform.posix.sprintf
-
-@OptIn(ExperimentalForeignApi::class)
-actual fun Float.fixed(signs: Int): Float {
-    return memScoped {
-        val buff = allocArray<ByteVar>(Float.SIZE_BYTES * 2)
-
-        sprintf(buff, "%.${signs}f", this@fixed)
-        buff.toKString().toFloat()
-    }
-}
-
-@OptIn(ExperimentalForeignApi::class)
-actual fun Double.fixed(signs: Int): Double {
-    return memScoped {
-        val buff = allocArray<ByteVar>(Double.SIZE_BYTES * 2)
-
-        sprintf(buff, "%.${signs}f", this@fixed)
-        buff.toKString().toDouble()
-    }
-}

common/src/mingwX64Main/kotlin/ActualMPPFile.kt

@@ -1,36 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import okio.FileSystem
-import okio.Path
-import okio.use
-
-actual typealias MPPFile = Path
-
-/**
- * @suppress
- */
-actual val MPPFile.filename: FileName
-    get() = FileName(toString())
-/**
- * @suppress
- */
-actual val MPPFile.filesize: Long
-    get() = FileSystem.SYSTEM.openReadOnly(this).use {
-        it.size()
-    }
-/**
- * @suppress
- */
-actual val MPPFile.bytesAllocatorSync: ByteArrayAllocator
-    get() = {
-        FileSystem.SYSTEM.read(this) {
-            readByteArray()
-        }
-    }
-/**
- * @suppress
- */
-actual val MPPFile.bytesAllocator: SuspendByteArrayAllocator
-    get() = {
-        bytesAllocatorSync()
-    }

common/src/mingwX64Main/kotlin/fixed.kt

@@ -1,25 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.cinterop.*
-import platform.posix.snprintf
-import platform.posix.sprintf
-
-@OptIn(ExperimentalForeignApi::class)
-actual fun Float.fixed(signs: Int): Float {
-    return memScoped {
-        val buff = allocArray<ByteVar>(Float.SIZE_BYTES * 2)
-
-        sprintf(buff, "%.${signs}f", this@fixed)
-        buff.toKString().toFloat()
-    }
-}
-
-@OptIn(ExperimentalForeignApi::class)
-actual fun Double.fixed(signs: Int): Double {
-    return memScoped {
-        val buff = allocArray<ByteVar>(Double.SIZE_BYTES * 2)
-
-        sprintf(buff, "%.${signs}f", this@fixed)
-        buff.toKString().toDouble()
-    }
-}

coroutines/build.gradle

@@ -22,7 +22,6 @@ kotlin {
             dependencies {
                 api libs.kt.coroutines.android
             }
-            dependsOn(jvmMain)
         }
     }
 }

coroutines/compose/src/androidMain/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest/>

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

@@ -1,46 +0,0 @@
-package dev.inmo.micro_utils.coroutines.compose
-
-import androidx.compose.runtime.MutableState
-import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This type works like [MutableState], [kotlinx.coroutines.flow.StateFlow] and [kotlinx.coroutines.flow.MutableSharedFlow].
- * Based on [SpecialMutableStateFlow]
- */
-@Deprecated("Will be removed soon")
-class FlowState<T>(
-    initial: T,
-    internalScope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) : MutableState<T>,
-    SpecialMutableStateFlow<T>(initial, internalScope) {
-    private var internalValue: T = initial
-    override var value: T
-        get() = internalValue
-        set(value) {
-            internalValue = value
-            tryEmit(value)
-        }
-
-    override fun onChangeWithoutSync(value: T) {
-        internalValue = value
-        super.onChangeWithoutSync(value)
-    }
-
-    override fun component1(): T = value
-
-    override fun component2(): (T) -> Unit = { tryEmit(it) }
-
-    override fun tryEmit(value: T): Boolean {
-        internalValue = value
-        return super.tryEmit(value)
-    }
-
-    override suspend fun emit(value: T) {
-        internalValue = value
-        super.emit(value)
-    }
-}
-
-//fun <T> MutableState<T>.asFlowState(scope: CoroutineScope = CoroutineScope(Dispatchers.Main)) = FlowState(this, scope)

coroutines/compose/src/jvmTest/kotlin/FlowStateTests.kt

@@ -0,0 +1,24 @@
+import androidx.compose.material.Button
+import androidx.compose.material.Text
+import androidx.compose.runtime.collectAsState
+import androidx.compose.ui.test.*
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import org.jetbrains.annotations.TestOnly
+import kotlin.test.Test
+
+class FlowStateTests {
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    @TestOnly
+    fun simpleTest() = runComposeUiTest {
+        val flowState = SpecialMutableStateFlow(0)
+        setContent {
+            Button({ flowState.value++ }) { Text("Click") }
+            Text(flowState.collectAsState().value.toString())
+        }
+
+        onNodeWithText(0.toString()).assertExists()
+        onNodeWithText("Click").performClick()
+        onNodeWithText(1.toString()).assertExists()
+    }
+}

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

@@ -0,0 +1,44 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
+
+typealias ExceptionHandler<T> = suspend (Throwable) -> T
+
+/**
+ * This instance will be used in all calls of [safely] where exception handler has not been passed
+ */
+var defaultSafelyExceptionHandler: ExceptionHandler<Nothing> = { throw it }
+
+/**
+ * This instance will be used in all calls of [safelyWithoutExceptions] as an exception handler for [safely] call
+ */
+var defaultSafelyWithoutExceptionHandler: ExceptionHandler<Unit> = {
+    try {
+        defaultSafelyExceptionHandler(it)
+    } catch (e: Throwable) {
+        // do nothing
+    }
+}
+
+/**
+ * This key can (and will) be used to get [ContextSafelyExceptionHandler] from [coroutineContext] of suspend functions
+ * and in [ContextSafelyExceptionHandler] for defining of its [CoroutineContext.Element.key]
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandler
+ */
+object ContextSafelyExceptionHandlerKey : CoroutineContext.Key<ContextSafelyExceptionHandler>
+
+/**
+ * [ExceptionHandler] wrapper which was created to make possible to use [handler] across all coroutines calls
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandlerKey
+ */
+class ContextSafelyExceptionHandler(
+    val handler: ExceptionHandler<Unit>
+) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*>
+        get() = ContextSafelyExceptionHandlerKey
+}

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

@@ -16,8 +16,8 @@ class DoWithFirstBuilder<T>(
     operator fun plus(block: suspend CoroutineScope.() -> T) {
         deferreds.add(scope.async(start = CoroutineStart.LAZY, block = block))
     }
-    inline fun add(noinline block: suspend CoroutineScope.() -> T) = plus(block)
-    inline fun include(noinline block: suspend CoroutineScope.() -> T) = plus(block)
+    fun add(block: suspend CoroutineScope.() -> T) = plus(block)
+    fun include(block: suspend CoroutineScope.() -> T) = plus(block)
 
     fun build() = deferreds.toList()
 }

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

@@ -85,32 +85,32 @@ fun <T, M> Flow<T>.subscribeAsync(
     return job
 }
 
-inline fun <T, M> Flow<T>.subscribeSafelyAsync(
+fun <T, M> Flow<T>.subscribeSafelyAsync(
     scope: CoroutineScope,
-    noinline markerFactory: suspend (T) -> M,
-    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
-    noinline block: suspend (T) -> Unit
+    markerFactory: suspend (T) -> M,
+    onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
+    block: suspend (T) -> Unit
 ) = subscribeAsync(scope, markerFactory) {
     safely(onException) {
         block(it)
     }
 }
 
-inline fun <T, M> Flow<T>.subscribeSafelyWithoutExceptionsAsync(
+fun <T, M> Flow<T>.subscribeSafelyWithoutExceptionsAsync(
     scope: CoroutineScope,
-    noinline markerFactory: suspend (T) -> M,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    noinline block: suspend (T) -> Unit
+    markerFactory: suspend (T) -> M,
+    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    block: suspend (T) -> Unit
 ) = subscribeAsync(scope, markerFactory) {
     safelyWithoutExceptions(onException) {
         block(it)
     }
 }
 
-inline fun <T, M> Flow<T>.subscribeSafelySkippingExceptionsAsync(
+fun <T, M> Flow<T>.subscribeSafelySkippingExceptionsAsync(
     scope: CoroutineScope,
-    noinline markerFactory: suspend (T) -> M,
-    noinline block: suspend (T) -> Unit
+    markerFactory: suspend (T) -> M,
+    block: suspend (T) -> Unit
 ) = subscribeAsync(scope, markerFactory) {
     safelyWithoutExceptions({ /* do nothing */}) {
         block(it)

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

@@ -4,46 +4,58 @@ import kotlinx.coroutines.*
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.coroutineContext
 
-typealias ExceptionHandler<T> = suspend (Throwable) -> T
-
 /**
- * This instance will be used in all calls of [safely] where exception handler has not been passed
+ * Launching [block] in [runCatching]. In case of failure, it will:
+ *
+ * * Try to get [ContextSafelyExceptionHandler] from current [coroutineContext] and call its
+ * [ContextSafelyExceptionHandler.handler] invoke. **Thrown exception from its handler
+ * will pass out of [runCatchingSafely]**
+ * * Execute [onException] inside of new [runCatching] and return its result. Throws exception
+ * will be caught by [runCatching] and wrapped in [Result]
+ *
+ * @return [Result] with result of [block] if no exceptions or [Result] from [onException] execution
  */
-var defaultSafelyExceptionHandler: ExceptionHandler<Nothing> = { throw it }
-
-/**
- * This instance will be used in all calls of [safelyWithoutExceptions] as an exception handler for [safely] call
- */
-var defaultSafelyWithoutExceptionHandler: ExceptionHandler<Unit> = {
-    try {
-        defaultSafelyExceptionHandler(it)
-    } catch (e: Throwable) {
-         // do nothing
+suspend inline fun <T> runCatchingSafely(
+    onException: ExceptionHandler<T>,
+    block: suspend () -> T
+): Result<T> {
+    return runCatching {
+        block()
+    }.onFailure {
+        coroutineContext[ContextSafelyExceptionHandlerKey] ?.handler ?.invoke(it)
+        return runCatching {
+            onException(it)
+        }
     }
 }
 
-/**
- * This key can (and will) be used to get [ContextSafelyExceptionHandler] from [coroutineContext] of suspend functions
- * and in [ContextSafelyExceptionHandler] for defining of its [CoroutineContext.Element.key]
- *
- * @see safelyWithContextExceptionHandler
- * @see ContextSafelyExceptionHandler
- */
-object ContextSafelyExceptionHandlerKey : CoroutineContext.Key<ContextSafelyExceptionHandler>
+suspend inline fun <T, R> R.runCatchingSafely(
+    onException: ExceptionHandler<T>,
+    block: suspend R.() -> T
+): Result<T> = runCatchingSafely<T>(onException) {
+    block()
+}
 
 /**
- * [ExceptionHandler] wrapper which was created to make possible to use [handler] across all coroutines calls
- *
- * @see safelyWithContextExceptionHandler
- * @see ContextSafelyExceptionHandlerKey
+ * Launching [runCatchingSafely] with [defaultSafelyExceptionHandler] as `onException` parameter
  */
-class ContextSafelyExceptionHandler(
-    val handler: ExceptionHandler<Unit>
-) : CoroutineContext.Element {
-    override val key: CoroutineContext.Key<*>
-        get() = ContextSafelyExceptionHandlerKey
+suspend inline fun <T> runCatchingSafely(
+    block: suspend () -> T
+): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+
+suspend inline fun <T, R> R.runCatchingSafely(
+    block: suspend R.() -> T
+): Result<T> = runCatchingSafely<T> {
+    block()
 }
 
+//suspend inline fun <T, R> T.runCatchingSafely(
+//    onException: ExceptionHandler<R>,
+//    block: suspend T.() -> R
+//): Result<R> = runCatchingSafely(onException) {
+//    block()
+//}
+
 /**
  * @return [ContextSafelyExceptionHandler] from [coroutineContext] by key [ContextSafelyExceptionHandlerKey] if
  * exists
@@ -51,7 +63,7 @@ class ContextSafelyExceptionHandler(
  * @see ContextSafelyExceptionHandler
  * @see ContextSafelyExceptionHandlerKey
  */
-suspend inline fun contextSafelyExceptionHandler() = coroutineContext[ContextSafelyExceptionHandlerKey]
+suspend fun contextSafelyExceptionHandler() = coroutineContext[ContextSafelyExceptionHandlerKey]
 
 /**
  * This method will set new [coroutineContext] with [ContextSafelyExceptionHandler]. In case if [coroutineContext]
@@ -64,7 +76,7 @@ suspend inline fun contextSafelyExceptionHandler() = coroutineContext[ContextSaf
 suspend fun <T> safelyWithContextExceptionHandler(
     contextExceptionHandler: ExceptionHandler<Unit>,
     safelyExceptionHandler: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    block: suspend CoroutineScope.() -> T
+    block: suspend () -> T
 ): T {
     val contextSafelyExceptionHandler = contextSafelyExceptionHandler() ?.handler ?.let { oldHandler ->
         ContextSafelyExceptionHandler {
@@ -78,57 +90,35 @@ suspend fun <T> safelyWithContextExceptionHandler(
 }
 
 /**
- * It will run [block] inside of [supervisorScope] to avoid problems with catching of exceptions
+ * Calls [runCatchingSafely] and getting the result via [Result.getOrThrow]
  *
- * Priorities of [ExceptionHandler]s:
- *
- * * [onException] In case if custom (will be used anyway if not [defaultSafelyExceptionHandler])
- * * [CoroutineContext.get] with [SafelyExceptionHandlerKey] as key
- * * [defaultSafelyExceptionHandler]
- *
- * Remember, that [ExceptionHandler] from [CoroutineContext.get] will be used anyway if it is available. After it will
- * be called [onException]
- *
- * @param [onException] Will be called when happen exception inside of [block]. By default will throw exception - this
- * exception will be available for catching
- *
- * @see defaultSafelyExceptionHandler
- * @see safelyWithoutExceptions
- * @see safelyWithContextExceptionHandler
+ * @see runCatchingSafely
  */
 suspend inline fun <T> safely(
-    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    noinline block: suspend CoroutineScope.() -> T
-): T {
-    return try {
-        supervisorScope(block)
-    } catch (e: Throwable) {
-        coroutineContext[ContextSafelyExceptionHandlerKey] ?.handler ?.invoke(e)
-        onException(e)
-    }
-}
+    onException: ExceptionHandler<T>,
+    block: suspend () -> T
+): T = runCatchingSafely(onException, block).getOrThrow()
 
-suspend inline fun <T> runCatchingSafely(
-    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    noinline block: suspend CoroutineScope.() -> T
-): Result<T> = runCatching {
-    safely(onException, block)
-}
+/**
+ * Calls [safely] with passing of [defaultSafelyExceptionHandler] as `onException`
+ *
+ * @see runCatchingSafely
+ */
+suspend inline fun <T> safely(
+    block: suspend () -> T
+): T = safely(defaultSafelyExceptionHandler, block)
+suspend inline fun <T, R> R.safely(
+    block: suspend R.() -> T
+): T = safely<T> { block() }
 
-suspend inline fun <T, R> T.runCatchingSafely(
-    noinline onException: ExceptionHandler<R> = defaultSafelyExceptionHandler,
-    noinline block: suspend T.() -> R
-): Result<R> = runCatching {
-    safely(onException) { block() }
-}
-
-suspend inline fun <T> safelyWithResult(
-    noinline block: suspend CoroutineScope.() -> T
+@Deprecated("Renamed", ReplaceWith("runCatchingSafely(block)", "dev.inmo.micro_utils.coroutines.runCatchingSafely"))
+suspend fun <T> safelyWithResult(
+    block: suspend () -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
-
-suspend inline fun <T, R> T.safelyWithResult(
-    noinline block: suspend T.() -> R
-): Result<R> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+@Deprecated("Renamed", ReplaceWith("this.runCatchingSafely(block)", "dev.inmo.micro_utils.coroutines.runCatchingSafely"))
+suspend fun <T, R> R.safelyWithResult(
+    block: suspend R.() -> T
+): Result<T> = safelyWithResult<T> { block() }
 
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
@@ -147,21 +137,23 @@ 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)
  */
-suspend inline fun <T> safelyWithoutExceptions(
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    noinline block: suspend CoroutineScope.() -> T
-): T? = safely(onException, block)
+suspend fun <T> safelyWithoutExceptions(
+    onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    block: suspend () -> T
+): T? = runCatchingSafely(onException, block).getOrNull()
 
-suspend inline fun <T> runCatchingSafelyWithoutExceptions(
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    noinline block: suspend CoroutineScope.() -> T
-): Result<T?> = runCatching {
-    safelyWithoutExceptions(onException, block)
+suspend fun <T> runCatchingSafelyWithoutExceptions(
+    onException: ExceptionHandler<T?> = defaultSafelyExceptionHandler,
+    block: suspend () -> T
+): Result<T?> = runCatchingSafely(onException, block).let {
+    if (it.isFailure) return Result.success<T?>(null)
+
+    it
 }
 
-inline fun CoroutineScope(
+fun CoroutineScopeWithDefaultFallback(
     context: CoroutineContext,
-    noinline defaultExceptionsHandler: ExceptionHandler<Unit>
+    defaultExceptionsHandler: ExceptionHandler<Unit>
 ) = CoroutineScope(
     context + ContextSafelyExceptionHandler(defaultExceptionsHandler)
 )

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

@@ -4,38 +4,46 @@ import kotlinx.coroutines.*
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-inline fun CoroutineScope.launchSafely(
+fun CoroutineScope.launchSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
-    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
-    noinline block: suspend CoroutineScope.() -> Unit
+    onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
+    block: suspend CoroutineScope.() -> Unit
 ) = launch(context, start) {
-    safely(onException, block)
+    runCatchingSafely(onException) {
+        block()
+    }
 }
 
-inline fun CoroutineScope.launchSafelyWithoutExceptions(
+fun CoroutineScope.launchSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
-    noinline onException: ExceptionHandler<Unit?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    noinline block: suspend CoroutineScope.() -> Unit
+    onException: ExceptionHandler<Unit?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    block: suspend CoroutineScope.() -> Unit
 ) = launch(context, start) {
-    safelyWithoutExceptions(onException, block)
+    runCatchingSafelyWithoutExceptions(onException) {
+        block()
+    }
 }
 
-inline fun <T> CoroutineScope.asyncSafely(
+fun <T> CoroutineScope.asyncSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
-    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    noinline block: suspend CoroutineScope.() -> T
+    onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    block: suspend CoroutineScope.() -> T
 ) = async(context, start) {
-    safely(onException, block)
+    runCatchingSafely(onException) {
+        block()
+    }
 }
 
-inline fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
+fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
-    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    noinline block: suspend CoroutineScope.() -> T
+    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+    block: suspend CoroutineScope.() -> T
 ) = async(context, start) {
-    safelyWithoutExceptions(onException, block)
+    runCatchingSafelyWithoutExceptions(onException) {
+        block()
+    }
 }

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

@@ -44,7 +44,7 @@ sealed interface SmartMutex {
      * @param locked Preset state of [isLocked] and its internal [_lockStateFlow]
      */
     class Mutable(locked: Boolean = false) : SmartMutex {
-        private val _lockStateFlow = MutableStateFlow<Boolean>(locked)
+        private val _lockStateFlow = SpecialMutableStateFlow<Boolean>(locked)
         override val lockStateFlow: StateFlow<Boolean> = _lockStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex()

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

@@ -45,7 +45,7 @@ sealed interface SmartSemaphore {
      * @param locked Preset state of [freePermits] and its internal [_freePermitsStateFlow]
      */
     class Mutable(private val permits: Int, acquiredPermits: Int = 0) : SmartSemaphore {
-        private val _freePermitsStateFlow = MutableStateFlow<Int>(permits - acquiredPermits)
+        private val _freePermitsStateFlow = SpecialMutableStateFlow<Int>(permits - acquiredPermits)
         override val permitsStateFlow: StateFlow<Int> = _freePermitsStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex(false)

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

@@ -11,76 +11,60 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.internal.SynchronizedObject
 import kotlinx.coroutines.internal.synchronized
+import kotlin.coroutines.CoroutineContext
 
 /**
  * Works like [StateFlow], but guarantee that latest value update will always be delivered to
  * each active subscriber
  */
 open class SpecialMutableStateFlow<T>(
-    initialValue: T,
-    internalScope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+    initialValue: T
 ) : MutableStateFlow<T>, FlowCollector<T>, MutableSharedFlow<T> {
     @OptIn(InternalCoroutinesApi::class)
     private val syncObject = SynchronizedObject()
-    protected val internalSharedFlow: MutableSharedFlow<T> = MutableSharedFlow(
-        replay = 0,
-        extraBufferCapacity = 2,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST
-    )
-    protected val publicSharedFlow: MutableSharedFlow<T> = MutableSharedFlow(
+    protected val sharingFlow: MutableSharedFlow<T> = MutableSharedFlow(
         replay = 1,
         extraBufferCapacity = 1,
         onBufferOverflow = BufferOverflow.DROP_OLDEST
     )
 
-    protected var _value: T = initialValue
-    override var value: T
-        get() = _value
+    @OptIn(InternalCoroutinesApi::class)
+    override var value: T = initialValue
         set(value) {
-            doOnChangeAction(value)
+            synchronized(syncObject) {
+                if (field != value) {
+                    field = value
+                    sharingFlow.tryEmit(value)
+                }
             }
-    protected val job = internalSharedFlow.subscribe(internalScope) {
-        doOnChangeAction(it)
         }
 
     override val replayCache: List<T>
-        get() = publicSharedFlow.replayCache
+        get() = sharingFlow.replayCache
     override val subscriptionCount: StateFlow<Int>
-        get() = publicSharedFlow.subscriptionCount
+        get() = sharingFlow.subscriptionCount
+
+    init {
+        sharingFlow.tryEmit(initialValue)
+    }
 
-    @OptIn(InternalCoroutinesApi::class)
     override fun compareAndSet(expect: T, update: T): Boolean {
-        return synchronized(syncObject) {
-            if (expect == _value && update != _value) {
-                doOnChangeAction(update)
-            }
-            expect == _value
-        }
-    }
-
-    protected open fun onChangeWithoutSync(value: T) {
-        _value = value
-        publicSharedFlow.tryEmit(value)
-    }
-    @OptIn(InternalCoroutinesApi::class)
-    protected open fun doOnChangeAction(value: T) {
-        synchronized(syncObject) {
-            if (_value != value) {
-                onChangeWithoutSync(value)
-            }
+        if (expect == value) {
+            value = update
         }
+        return expect == value
     }
 
     @ExperimentalCoroutinesApi
-    override fun resetReplayCache() = publicSharedFlow.resetReplayCache()
+    override fun resetReplayCache() = sharingFlow.resetReplayCache()
 
     override fun tryEmit(value: T): Boolean {
-        return internalSharedFlow.tryEmit(value)
+        return compareAndSet(this.value, value)
     }
 
     override suspend fun emit(value: T) {
-        internalSharedFlow.emit(value)
+        compareAndSet(this.value, value)
     }
 
-    override suspend fun collect(collector: FlowCollector<T>) = publicSharedFlow.collect(collector)
+    override suspend fun collect(collector: FlowCollector<T>) = sharingFlow.collect(collector)
 }

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

@@ -10,8 +10,12 @@ fun CoroutineScope.LinkedSupervisorJob(
     additionalContext: CoroutineContext? = null
 ) = coroutineContext.LinkedSupervisorJob(additionalContext)
 
-fun CoroutineScope.LinkedSupervisorScope(
+
+fun CoroutineContext.LinkedSupervisorScope(
     additionalContext: CoroutineContext? = null
 ) = CoroutineScope(
-    coroutineContext + LinkedSupervisorJob(additionalContext)
+    this + LinkedSupervisorJob(additionalContext)
 )
+fun CoroutineScope.LinkedSupervisorScope(
+    additionalContext: CoroutineContext? = null
+) = coroutineContext.LinkedSupervisorScope(additionalContext)

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

@@ -4,28 +4,71 @@ import kotlinx.coroutines.*
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-private fun CoroutineScope.createWeakSubScope() = CoroutineScope(coroutineContext.minusKey(Job)).also { newScope ->
-    coroutineContext.job.invokeOnCompletion { newScope.cancel() }
+/**
+ * Created [CoroutineScope] which will [launch] listening of [context] job completing and drop itself. Current weak
+ * scope **will not** be attached to [context] directly. So, this [CoroutineScope] will not prevent parent one from
+ * cancelling if it is launched with [supervisorScope] or [coroutineScope], but still will follow closing status
+ * of parent [Job]
+ */
+fun WeakScope(
+    context: CoroutineContext
+) = CoroutineScope(context.minusKey(Job) + Job()).also { newScope ->
+    newScope.launch {
+        context.job.join()
+        newScope.cancel()
+    }
 }
 
-fun CoroutineScope.weakLaunch(
+/**
+ * Created [CoroutineScope] which will [launch] listening of [scope] [CoroutineContext] job completing and drop itself. Current weak
+ * scope **will not** be attached to [scope] [CoroutineContext] directly. So, this [CoroutineScope] will not prevent parent one from
+ * cancelling if it is launched with [supervisorScope] or [coroutineScope], but still will follow closing status
+ * of parent [Job]
+ */
+fun WeakScope(
+    scope: CoroutineScope
+) = WeakScope(scope.coroutineContext)
+
+/**
+ * [this] [CoroutineScope] will be used as base for [WeakScope]. Other parameters ([context], [start], [block])
+ * will be used to [launch] [Job]
+ */
+fun CoroutineScope.launchWeak(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     block: suspend CoroutineScope.() -> Unit
 ): Job {
-    val scope = createWeakSubScope()
+    val scope = WeakScope(this)
     val job = scope.launch(context, start, block)
     job.invokeOnCompletion { scope.cancel() }
     return job
 }
 
-fun <T> CoroutineScope.weakAsync(
+/**
+ * [this] [CoroutineScope] will be used as base for [WeakScope]. Other parameters ([context], [start], [block])
+ * will be used to create [async] [Deferred]
+ */
+fun <T> CoroutineScope.asyncWeak(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     block: suspend CoroutineScope.() -> T
 ): Deferred<T> {
-    val scope = createWeakSubScope()
+    val scope = WeakScope(this)
     val deferred = scope.async(context, start, block)
     deferred.invokeOnCompletion { scope.cancel() }
     return deferred
 }
+
+@Deprecated("Renamed", ReplaceWith("launchWeak(context, start, block)", "dev.inmo.micro_utils.coroutines.launchWeak"))
+fun CoroutineScope.weakLaunch(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> Unit
+): Job = launchWeak(context, start, block)
+
+@Deprecated("Renamed", ReplaceWith("asyncWeak(context, start, block)", "dev.inmo.micro_utils.coroutines.asyncWeak"))
+fun <T> CoroutineScope.weakAsync(
+    context: CoroutineContext = EmptyCoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> T
+): Deferred<T> = asyncWeak(context, start, block)

coroutines/src/commonTest/kotlin/SpecialMutableStateFlowTests.kt

@@ -0,0 +1,33 @@
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import dev.inmo.micro_utils.coroutines.asDeferred
+import dev.inmo.micro_utils.coroutines.subscribe
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class SpecialMutableStateFlowTests {
+    @Test
+    fun simpleTest() = runTest {
+        val specialMutableStateFlow = SpecialMutableStateFlow(0)
+        specialMutableStateFlow.value = 1
+        specialMutableStateFlow.first { it == 1 }
+        assertEquals(1, specialMutableStateFlow.value)
+    }
+    @Test
+    fun specialTest() = runTest {
+        val specialMutableStateFlow = SpecialMutableStateFlow(0)
+        lateinit var subscriberJob: Job
+        subscriberJob = specialMutableStateFlow.subscribe(this) {
+            when (it) {
+                1 -> specialMutableStateFlow.value = 2
+                2 -> subscriberJob.cancel()
+            }
+        }
+        specialMutableStateFlow.value = 1
+        subscriberJob.join()
+        assertEquals(2, specialMutableStateFlow.value)
+    }
+}

coroutines/src/commonTest/kotlin/WeakJobTests.kt

@@ -0,0 +1,64 @@
+import dev.inmo.micro_utils.coroutines.asyncWeak
+import dev.inmo.micro_utils.coroutines.launchWeak
+import kotlinx.coroutines.*
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class WeakJobTests {
+    @Test
+    fun testWeakJob() = runTest {
+        var commonJobDone = false
+        var weakJobStarted = false
+        try {
+            coroutineScope {
+                launch {
+                    delay(1000)
+                    commonJobDone = true
+                }
+                asyncWeak {
+                    weakJobStarted = true
+                    delay(100500L)
+                    error("This must never happen")
+                }
+            }.await()
+        } catch (error: Throwable) {
+            assertTrue(error is CancellationException)
+            assertTrue(commonJobDone)
+            assertTrue(weakJobStarted)
+            return@runTest
+        }
+        error("Cancellation exception has not been thrown")
+    }
+    @Test
+    fun testThatWeakJobsWorksCorrectly() = runTest {
+        val scope = CoroutineScope(Dispatchers.Default)
+        lateinit var weakLaunchJob: Job
+        lateinit var weakAsyncJob: Job
+        val completeDeferred = Job()
+        coroutineScope {
+            weakLaunchJob = launchWeak {
+                while (isActive) {
+                    delay(100L)
+                }
+            }
+            weakAsyncJob = asyncWeak {
+                while (isActive) {
+                    delay(100L)
+                }
+            }
+
+            coroutineContext.job.invokeOnCompletion {
+                scope.launch {
+                    delay(1000L)
+                    completeDeferred.complete()
+                }
+            }
+            launch { delay(1000L); cancel() }
+        }
+        completeDeferred.join()
+
+        assertTrue(!weakLaunchJob.isActive)
+        assertTrue(!weakAsyncJob.isActive)
+    }
+}

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

@@ -1,40 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import kotlinx.coroutines.*
-import org.junit.Test
-
-class WeakJob {
-    @Test
-    fun `test that weak jobs works correctly`() {
-        val scope = CoroutineScope(Dispatchers.Default)
-        lateinit var weakLaunchJob: Job
-        lateinit var weakAsyncJob: Job
-        scope.launchSynchronously {
-            val completeDeferred = Job()
-            coroutineScope {
-                weakLaunchJob = weakLaunch {
-                    while (isActive) {
-                        delay(100L)
-                    }
-                }
-                weakAsyncJob = weakAsync {
-                    while (isActive) {
-                        delay(100L)
-                    }
-                }
-
-                coroutineContext.job.invokeOnCompletion {
-                    scope.launch {
-                        delay(1000L)
-                        completeDeferred.complete()
-                    }
-                }
-                launch { delay(1000L); cancel() }
-            }
-            completeDeferred.join()
-        }
-
-        assert(!weakLaunchJob.isActive)
-        assert(!weakAsyncJob.isActive)
-    }
-}

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

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.fsm.common
 
 import dev.inmo.micro_utils.common.Optional
-import dev.inmo.micro_utils.common.onPresented
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
 import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
@@ -118,15 +117,17 @@ open class DefaultStatesMachine <T: State>(
      * [launchStateHandling] will returns some [State] then [statesManager] [StatesManager.update] will be used, otherwise
      * [StatesManager.endChain].
      */
-    override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
-        (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(this) {
-            launch { performStateUpdate(Optional.absent(), it, scope.LinkedSupervisorScope()) }
+    override fun start(scope: CoroutineScope): Job {
+        val supervisorScope = scope.LinkedSupervisorScope()
+        supervisorScope.launchSafelyWithoutExceptions {
+            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(supervisorScope) {
+                supervisorScope.launch { performStateUpdate(Optional.absent(), it, supervisorScope) }
             }
-        statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
-            launch { performStateUpdate(Optional.presented(it.first), it.second, scope.LinkedSupervisorScope()) }
+            statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(supervisorScope) {
+                supervisorScope.launch { performStateUpdate(Optional.presented(it.first), it.second, supervisorScope) }
             }
-        statesManager.onEndChain.subscribeSafelyWithoutExceptions(this) { removedState ->
-            launch {
+            statesManager.onEndChain.subscribeSafelyWithoutExceptions(supervisorScope) { removedState ->
+                supervisorScope.launch {
                     statesJobsMutex.withLock {
                         val stateInMap = statesJobs.keys.firstOrNull { stateInMap -> stateInMap == removedState }
                         if (stateInMap === removedState) {
@@ -137,6 +138,9 @@ open class DefaultStatesMachine <T: State>(
             }
         }
 
+        return supervisorScope.coroutineContext.job
+    }
+
     /**
      * Just calls [StatesManager.startChain] of [statesManager]
      */

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.20.44
-android_code_version=250
+version=0.21.1
+android_code_version=260

gradle/libs.versions.toml

@@ -2,18 +2,18 @@
 
 kt = "1.9.23"
 kt-serialization = "1.6.3"
-kt-coroutines = "1.8.0"
+kt-coroutines = "1.8.1"
 
-kslog = "1.3.3"
+kslog = "1.3.4"
 
 jb-compose = "1.6.2"
-jb-exposed = "0.49.0"
+jb-exposed = "0.50.1"
 jb-dokka = "1.9.20"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "2.3.10"
+ktor = "2.3.11"
 
 gh-release = "2.5.2"
 
@@ -26,13 +26,13 @@ kotlin-poet = "1.16.0"
 
 versions = "0.51.0"
 
-android-gradle = "8.3.2"
+android-gradle = "8.2.0"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.12.0"
+android-coreKtx = "1.13.1"
 android-recyclerView = "1.3.2"
 android-appCompat = "1.6.1"
-android-fragment = "1.6.2"
+android-fragment = "1.7.1"
 android-espresso = "3.5.1"
 android-test = "1.1.5"
 android-compose-material3 = "1.2.1"

ksp/generator/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+}
+
+apply from: "$publishJvmOnlyPath"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api project(":micro_utils.common")
+    api libs.kotlin.poet
+    api libs.ksp
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

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

@@ -0,0 +1,49 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSFile
+import com.squareup.kotlinpoet.FileSpec
+import java.io.File
+
+fun KSClassDeclaration.writeFile(
+    prefix: String = "",
+    suffix: String = "",
+    relatedPath: String = "",
+    force: Boolean = false,
+    fileSpecBuilder: () -> FileSpec
+) {
+    val containingFile = containingFile!!
+    File(
+        File(
+            File(containingFile.filePath).parent,
+            relatedPath
+        ),
+        "$prefix${simpleName.asString()}$suffix.kt"
+    ).takeIf { force || !it.exists() } ?.apply {
+        parentFile.mkdirs()
+        writer().use { writer ->
+            fileSpecBuilder().writeTo(writer)
+        }
+    }
+}
+
+fun KSFile.writeFile(
+    prefix: String = "",
+    suffix: String = "",
+    relatedPath: String = "",
+    force: Boolean = false,
+    fileSpecBuilder: () -> FileSpec
+) {
+    File(
+        File(
+            File(filePath).parent,
+            relatedPath
+        ),
+        "$prefix${fileName.dropLastWhile { it != '.' }.removeSuffix(".")}$suffix.kt"
+    ).takeIf { force || !it.exists() } ?.apply {
+        parentFile.mkdirs()
+        writer().use { writer ->
+            fileSpecBuilder().writeTo(writer)
+        }
+    }
+}

ksp/sealed/build.gradle

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

ksp/sealed/generator/build.gradle

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

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

@@ -0,0 +1,110 @@
+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.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.AnnotationSpec
+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.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.writeFile
+import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround
+
+class Processor(
+    private val codeGenerator: CodeGenerator
+) : SymbolProcessor {
+    private fun KSClassDeclaration.resolveSubclasses(): List<KSClassDeclaration> {
+        return (getSealedSubclasses().flatMap {
+            it.resolveSubclasses()
+        }.ifEmpty {
+            sequenceOf(this)
+        }).toList()
+    }
+
+    @OptIn(KspExperimental::class)
+    private fun FileSpec.Builder.generateSealedWorkaround(
+        ksClassDeclaration: KSClassDeclaration,
+        resolver: Resolver
+    ) {
+        val subClasses = ksClassDeclaration.resolveSubclasses().distinct()
+        val subClassesNames = subClasses.filter {
+            when (it.classKind) {
+                ClassKind.ENUM_ENTRY,
+                ClassKind.OBJECT -> true
+                ClassKind.INTERFACE,
+                ClassKind.CLASS,
+                ClassKind.ENUM_CLASS,
+                ClassKind.ANNOTATION_CLASS -> false
+            }
+        }.filter {
+            it.getAnnotationsByType(GenerateSealedWorkaround.Exclude::class).count() == 0
+        }.sortedBy {
+            (it.getAnnotationsByType(GenerateSealedWorkaround.Order::class).firstOrNull()) ?.order ?: 0
+        }.map {
+            it.toClassName()
+        }
+        val className = ksClassDeclaration.toClassName()
+        val setType = Set::class.asTypeName().parameterizedBy(
+            ksClassDeclaration.toClassName()
+        )
+        addProperty(
+            PropertySpec.builder(
+                "values",
+                setType
+            ).apply {
+                modifiers.add(
+                    KModifier.PRIVATE
+                )
+                initializer(
+                    CodeBlock.of(
+                        """setOf(${subClassesNames.joinToString(",\n") {it.simpleNames.joinToString(".")}})"""
+                    )
+                )
+            }.build()
+        )
+        addFunction(
+            FunSpec.builder("values").apply {
+                receiver(ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion"))
+                returns(setType)
+                addCode(
+                    CodeBlock.of(
+                        """return values"""
+                    )
+                )
+            }.build()
+        )
+    }
+
+    @OptIn(KspExperimental::class)
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        (resolver.getSymbolsWithAnnotation(GenerateSealedWorkaround::class.qualifiedName!!)).filterIsInstance<KSClassDeclaration>().forEach {
+            val prefix = it.getAnnotationsByType(GenerateSealedWorkaround::class).first().prefix
+            it.writeFile(prefix = prefix, suffix = "SealedWorkaround") {
+                FileSpec.builder(
+                    it.packageName.asString(),
+                    "${it.simpleName.getShortName()}SealedWorkaround"
+                ).apply {
+                    addFileComment(
+                        """
+                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+                        TO REGENERATE IT JUST DELETE FILE
+                        ORIGINAL FILE: ${it.containingFile ?.fileName}
+                        """.trimIndent()
+                    )
+                    generateSealedWorkaround(it, resolver)
+                }.build()
+            }
+        }
+
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.ksp.sealed.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/sealed/generator/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

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

ksp/sealed/generator/test/build.gradle

@@ -0,0 +1,27 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+    id "com.google.devtools.ksp"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":micro_utils.ksp.sealed")
+            }
+        }
+    }
+}
+
+
+dependencies {
+    add("kspCommonMainMetadata", project(":micro_utils.ksp.sealed.generator"))
+}
+
+ksp {
+}

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

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

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

@@ -0,0 +1,11 @@
+// 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
+
+private val values: Set<Test> = setOf(Test.C,
+    Test.A)
+
+public fun Test.Companion.values(): Set<Test> = values

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

@@ -0,0 +1,14 @@
+package dev.inmo.microutils.kps.sealed
+
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.CLASS)
+annotation class GenerateSealedWorkaround(
+    val prefix: String = ""
+) {
+    @Retention(AnnotationRetention.BINARY)
+    @Target(AnnotationTarget.CLASS)
+    annotation class Order(val order: Int)
+    @Retention(AnnotationRetention.BINARY)
+    @Target(AnnotationTarget.CLASS)
+    annotation class Exclude
+}

ktor/client/build.gradle

@@ -15,9 +15,6 @@ kotlin {
                 api libs.ktor.client
             }
         }
-        androidMain {
-            dependsOn jvmMain
-        }
 
         linuxX64Main {
             dependencies {

ktor/common/build.gradle

@@ -12,13 +12,9 @@ kotlin {
             dependencies {
                 api internalProject("micro_utils.common")
                 api libs.kt.serialization.cbor
-                api libs.klock
                 api libs.uuid
                 api libs.ktor.io
             }
         }
-        androidMain {
-            dependsOn jvmMain
-        }
     }
 }

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

@@ -41,7 +41,7 @@ class TemporalFilesRoutingConfigurator(
                     filesMutex: Mutex,
                     onNewFileFlow: Flow<TemporalFileId>
                 ): Job = scope.launchSafelyWithoutExceptions {
-                    while (isActive) {
+                    while (currentCoroutineContext().isActive) {
                         val filesWithCreationInfo = filesMap.mapNotNull { (fileId, file) ->
                             fileId to ((Files.getAttribute(file.toPath(), "creationTime") as? FileTime) ?.toMillis() ?: return@mapNotNull null)
                         }

language_codes/build.gradle

@@ -5,11 +5,3 @@ plugins {
 }
 
 apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
-
-kotlin {
-    sourceSets {
-        androidMain {
-            dependsOn jvmMain
-        }
-    }
-}

language_codes/src/commonMain/kotlin/dev/inmo/micro_utils/language_codes/LanguageCodes.kt

@@ -1,3 +1,5 @@
+@file:Suppress("SERIALIZER_TYPE_INCOMPATIBLE") // for suppressing of @Serializable(IetfLangSerializer::class) on inheritors of IetfLang
+
 package dev.inmo.micro_utils.language_codes
 
 import kotlinx.serialization.Serializable

mppJvmJsAndroidLinuxMingwLinuxArm64Project.gradle

@@ -60,6 +60,12 @@ kotlin {
                 implementation kotlin('test-junit')
             }
         }
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+        linuxArm64Main.dependsOn nativeMain
+
+        androidMain.dependsOn jvmMain
     }
 }
 

mppJvmJsLinuxMingwLinuxArm64Project.gradle

@@ -45,6 +45,13 @@ kotlin {
                 implementation kotlin('test-junit')
             }
         }
+
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+        linuxArm64Main.dependsOn nativeMain
+
+        androidMain.dependsOn jvmMain
     }
 }
 

mppJvmJsLinuxMingwProject.gradle

@@ -55,6 +55,10 @@ kotlin {
             }
         }
 
+        nativeMain.dependsOn commonMain
+        linuxX64Main.dependsOn nativeMain
+        mingwX64Main.dependsOn nativeMain
+
         androidMain.dependsOn jvmMain
     }
 }

mppProjectWithSerializationAndCompose.gradle

@@ -28,8 +28,8 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
-                api libs.kt.serialization
                 implementation compose.runtime
+                api libs.kt.serialization
             }
         }
         commonTest {
@@ -47,6 +47,7 @@ kotlin {
         jvmTest {
             dependencies {
                 implementation kotlin('test-junit')
+                implementation compose.uiTest
             }
         }
         jsMain {
@@ -61,14 +62,20 @@ kotlin {
             }
         }
         androidUnitTest {
+            dependencies {
+                implementation kotlin('test-junit')
+                implementation libs.android.test.junit
+                implementation libs.android.espresso
+                implementation compose.uiTest
+            }
+        }
+        androidInstrumentedTest {
             dependencies {
                 implementation kotlin('test-junit')
                 implementation libs.android.test.junit
                 implementation libs.android.espresso
             }
         }
-
-        androidMain.dependsOn jvmMain
     }
 }
 

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

@@ -20,7 +20,13 @@ data class PaginationResult<T>(
      * Amount of pages for current pagination
      */
     @EncodeDefault
-    val pagesNumber: Int = ceil(objectsNumber / size.toFloat()).toInt()
+    @SerialName("pagesNumber")
+    val pagesNumberLong: Long = ceil(objectsNumber / size.toFloat()).toLong()
+    /**
+     * Amount of pages for current pagination
+     */
+    @Transient
+    val pagesNumber: Int = pagesNumberLong.toInt()
 
     constructor(
         page: Int,
@@ -35,31 +41,58 @@ data class PaginationResult<T>(
     )
 }
 
-fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0L)
+val PaginationResult<*>.lastPageLong
+    get() = pagesNumberLong - 1
+
+val PaginationResult<*>.lastPage
+    get() = lastPageLong.toInt()
+
+val PaginationResult<*>.isLastPage
+    get() = page.toLong() == lastPageLong
+
 fun <T> emptyPaginationResult(
-    basePagination: Pagination
+    basePagination: Pagination,
+    objectsNumber: Number
 ) = PaginationResult<T>(
     basePagination.page,
     basePagination.size,
     emptyList(),
-    0L
+    objectsNumber.toLong()
 )
+fun <T> emptyPaginationResult(
+    basePagination: Pagination,
+) = emptyPaginationResult<T>(basePagination, 0)
+fun <T> emptyPaginationResult() = emptyPaginationResult<T>(FirstPagePagination(0))
+
+/**
+ * @return New [PaginationResult] with [data] without checking of data sizes equality
+ */
+inline fun <I, O> PaginationResult<I>.changeResultsUnchecked(
+    block: PaginationResult<I>.() -> List<O>
+): PaginationResult<O> = PaginationResult(page, size, block(), objectsNumber)
 
 /**
  * @return New [PaginationResult] with [data] without checking of data sizes equality
  */
 fun <I, O> PaginationResult<I>.changeResultsUnchecked(
     data: List<O>
-): PaginationResult<O> = PaginationResult(page, size, data, objectsNumber)
+): PaginationResult<O> = changeResultsUnchecked { data }
+/**
+ * @return New [PaginationResult] with [data] <b>with</b> checking of data sizes equality
+ */
+inline fun <I, O> PaginationResult<I>.changeResults(
+    block: PaginationResult<I>.() -> List<O>
+): PaginationResult<O> {
+    val data = block()
+    require(data.size == results.size)
+    return changeResultsUnchecked(data)
+}
 /**
  * @return New [PaginationResult] with [data] <b>with</b> checking of data sizes equality
  */
 fun <I, O> PaginationResult<I>.changeResults(
     data: List<O>
-): PaginationResult<O> {
-    require(data.size == results.size)
-    return changeResultsUnchecked(data)
-}
+): PaginationResult<O> = changeResults { data }
 
 fun <T> List<T>.createPaginationResult(
     pagination: Pagination,

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

@@ -10,8 +10,7 @@ inline fun doWithPagination(
     }
 }
 
-@Suppress("NOTHING_TO_INLINE")
-inline fun PaginationResult<*>.nextPageIfNotEmpty() = if (results.isNotEmpty()) {
+inline fun <T, PR: PaginationResult<T>> PR.nextPageIfTrue(condition: PR.() -> Boolean) = if (condition()) {
     SimplePagination(
         page + 1,
         size
@@ -20,12 +19,28 @@ inline fun PaginationResult<*>.nextPageIfNotEmpty() = if (results.isNotEmpty())
     null
 }
 
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> PaginationResult<T>.thisPageIfNotEmpty(): PaginationResult<T>? = if (results.isNotEmpty()) {
+inline fun <T, PR: PaginationResult<T>> PR.thisPageIfTrue(condition: PR.() -> Boolean): PR? = if (condition()) {
     this
 } else {
     null
 }
 
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T> PaginationResult<T>.currentPageIfNotEmpty() = thisPageIfNotEmpty()
+fun PaginationResult<*>.nextPageIfNotEmpty() = nextPageIfTrue { results.isNotEmpty() }
+
+fun <T> PaginationResult<T>.thisPageIfNotEmpty(): PaginationResult<T>? = thisPageIfTrue { results.isNotEmpty() }
+
+fun <T> PaginationResult<T>.currentPageIfNotEmpty() = thisPageIfNotEmpty()
+
+
+fun PaginationResult<*>.nextPageIfNotEmptyOrLastPage() = nextPageIfTrue { results.isNotEmpty() && !this.isLastPage }
+
+fun <T> PaginationResult<T>.thisPageIfNotEmptyOrLastPage(): PaginationResult<T>? = thisPageIfTrue  { results.isNotEmpty() && !this.isLastPage }
+
+fun <T> PaginationResult<T>.currentPageIfNotEmptyOrLastPage() = thisPageIfNotEmptyOrLastPage()
+
+
+fun PaginationResult<*>.nextPageIfNotLastPage() = nextPageIfTrue { !this.isLastPage }
+
+fun <T> PaginationResult<T>.thisPageIfNotLastPage(): PaginationResult<T>? = thisPageIfTrue  { !this.isLastPage }
+
+fun <T> PaginationResult<T>.currentPageIfNotLastPage() = thisPageIfNotLastPage()

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/DoForAll.kt

@@ -18,7 +18,7 @@ inline fun <T> doForAllWithNextPaging(
 ) {
     doForAll(
         initialPagination,
-        { it.nextPageIfNotEmpty() },
+        { it.nextPageIfNotEmptyOrLastPage() },
         block
     )
 }
@@ -29,7 +29,7 @@ inline fun <T> doAllWithCurrentPaging(
 ) {
     doForAll(
         initialPagination,
-        { it.currentPageIfNotEmpty() },
+        { it.nextPageIfNotEmptyOrLastPage() },
         block
     )
 }

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/GetAll.kt

@@ -31,7 +31,7 @@ inline fun <T> getAllWithNextPaging(
     block: (Pagination) -> PaginationResult<T>
 ): List<T> = getAll(
     initialPagination,
-    { it.nextPageIfNotEmpty() },
+    { it.nextPageIfNotEmptyOrLastPage() },
     block
 )
 
@@ -48,7 +48,7 @@ inline fun <T> getAllWithCurrentPaging(
     block: (Pagination) -> PaginationResult<T>
 ): List<T> = getAll(
     initialPagination,
-    { it.currentPageIfNotEmpty() },
+    { it.thisPageIfNotEmptyOrLastPage() },
     block
 )
 

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/utils/Paginate.kt

@@ -21,33 +21,25 @@ fun <T> Iterable<T>.paginate(with: Pagination): PaginationResult<T> {
 }
 
 fun <T> List<T>.paginate(with: Pagination): PaginationResult<T> {
-    val firstIndex = maxOf(with.firstIndex, 0)
-    val lastIndex = minOf(with.lastIndexExclusive, size)
-    if (firstIndex > lastIndex) {
-        return emptyPaginationResult()
+    if (with.firstIndex >= size || with.lastIndex < 0) {
+        return emptyPaginationResult(with, size.toLong())
     }
-    return subList(firstIndex, lastIndex).createPaginationResult(
+    return asSequence().drop(with.firstIndex).take(with.size).toList().createPaginationResult(
         with,
         size.toLong()
     )
 }
 
 fun <T> List<T>.paginate(with: Pagination, reversed: Boolean): PaginationResult<T> {
+    return if (reversed) {
         val actualPagination = with.optionallyReverse(
             size,
             reversed
         )
-
-    val firstIndex = maxOf(actualPagination.firstIndex, 0)
-    val lastIndex = minOf(actualPagination.lastIndexExclusive, size)
-    if (firstIndex > lastIndex) {
-        return emptyPaginationResult()
+        paginate(actualPagination).changeResultsUnchecked { results.reversed() }
+    } else {
+        paginate(with)
     }
-
-    return subList(firstIndex, lastIndex).optionallyReverse(reversed).createPaginationResult(
-        with,
-        size.toLong()
-    )
 }
 
 fun <T> Set<T>.paginate(with: Pagination): PaginationResult<T> {

pagination/common/src/commonTest/kotlin/dev/inmo/micro_utils/pagination/utils/PaginationPaging.kt

@@ -0,0 +1,72 @@
+package dev.inmo.micro_utils.pagination.utils
+
+import dev.inmo.micro_utils.pagination.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class PaginationPaging {
+    @Test
+    fun testPaginateOnList() {
+        val list = (0 until 7).toList()
+        val startPagination = FirstPagePagination(2)
+
+        var lastPageHappened = false
+        doForAllWithNextPaging(startPagination) {
+            val result = list.paginate(it)
+
+            if (result.isLastPage) {
+                lastPageHappened = true
+                assertTrue(result.results.size == 1)
+            }
+
+            val testSublist = list.subList(it.firstIndex, minOf(it.lastIndexExclusive, list.size))
+            assertEquals(result.results, testSublist)
+
+            result
+        }
+
+        assertTrue(lastPageHappened)
+    }
+    @Test
+    fun testEmptyPaginateOnList() {
+        val list = listOf<Int>()
+        val startPagination = FirstPagePagination(2)
+
+        var paginationHappend = false
+        doForAllWithNextPaging(startPagination) {
+            val resultPagination = list.paginate(it)
+
+            assertEquals(resultPagination, emptyPaginationResult(it, list.size))
+
+            assertFalse(paginationHappend)
+
+            paginationHappend = true
+
+            resultPagination
+        }
+
+        assertTrue(paginationHappend)
+    }
+    @Test
+    fun testRightOutPaginateOnList() {
+        val list = (0 until 7).toList()
+        val startPagination = SimplePagination(page = 4, size = 2)
+
+        var paginationHappend = false
+        doForAllWithNextPaging(startPagination) {
+            val resultPagination = list.paginate(it)
+
+            assertEquals(resultPagination, emptyPaginationResult(it, list.size))
+
+            assertFalse(paginationHappend)
+
+            paginationHappend = true
+
+            resultPagination
+        }
+
+        assertTrue(paginationHappend)
+    }
+}

repos/common/build.gradle

@@ -28,7 +28,6 @@ kotlin {
                 api internalProject("micro_utils.common")
                 api internalProject("micro_utils.coroutines")
             }
-            dependsOn jvmMain
         }
     }
 }

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartCRUDRepo.kt

@@ -42,6 +42,22 @@ interface WriteCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
 }
 typealias WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> = WriteCRUDRepo<ObjectType, IdType, InputValueType>
 
+/**
+ * Just mirroring [WriteCRUDRepo.newObjectsFlow] to be same as in KV repos
+ */
+val <ObjectType> WriteCRUDRepo<ObjectType, *, *>.onNewObjects: Flow<ObjectType>
+    get() = newObjectsFlow
+/**
+ * Just mirroring [WriteCRUDRepo.updatedObjectsFlow] to be same as in KV repos
+ */
+val <ObjectType> WriteCRUDRepo<ObjectType, *, *>.onUpdatedObjects: Flow<ObjectType>
+    get() = updatedObjectsFlow
+/**
+ * Just mirroring [WriteCRUDRepo.deletedObjectsIdsFlow] to be same as in KV repos
+ */
+val <IdType> WriteCRUDRepo<*, IdType, *>.onDeletedObjectsIds: Flow<IdType>
+    get() = deletedObjectsIdsFlow
+
 suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.create(
     vararg values: InputValueType
 ): List<ObjectType> = create(values.toList())

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/diff/CRUDRepoDiff.kt

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.repos.diff
+
+import dev.inmo.micro_utils.common.MapDiff
+import dev.inmo.micro_utils.common.applyDiff
+import dev.inmo.micro_utils.common.diff
+import dev.inmo.micro_utils.repos.CRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
+import dev.inmo.micro_utils.repos.unset
+
+suspend fun <Id, Registered> ReadCRUDRepo<Registered, Id>.diff(other: Map<Id, Registered>): MapDiff<Id, Registered> {
+    return getAll().diff(other)
+}
+
+suspend fun <Id, Registered> Map<Id, Registered>.diff(other: ReadCRUDRepo<Registered, Id>): MapDiff<Id, Registered> {
+    return diff(other.getAll())
+}
+
+suspend fun <Id, Registered> MutableMap<Id, Registered>.applyDiff(other: ReadCRUDRepo<Registered, Id>) {
+    applyDiff(diff(other))
+}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/diff/KeyValueRepoDiff.kt

@@ -0,0 +1,33 @@
+package dev.inmo.micro_utils.repos.diff
+
+import dev.inmo.micro_utils.common.MapDiff
+import dev.inmo.micro_utils.common.applyDiff
+import dev.inmo.micro_utils.common.diff
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.unset
+
+suspend fun <Id, Registered> ReadKeyValueRepo<Id, Registered>.diff(other: Map<Id, Registered>): MapDiff<Id, Registered> {
+    return getAll().diff(other)
+}
+
+suspend fun <Id, Registered> Map<Id, Registered>.diff(other: ReadKeyValueRepo<Id, Registered>): MapDiff<Id, Registered> {
+    return diff(other.getAll())
+}
+
+suspend fun <Id, Registered> KeyValueRepo<Id, Registered>.applyDiff(diff: MapDiff<Id, Registered>) {
+    unset(diff.removed.map { it.key })
+    set(
+        diff.changed.map { (k, oldNew) ->
+            k to oldNew.second
+        }.toMap() + diff.added
+    )
+}
+
+suspend fun <Id, Registered> KeyValueRepo<Id, Registered>.applyDiff(other: Map<Id, Registered>) {
+    applyDiff(diff(other))
+}
+
+suspend fun <Id, Registered> MutableMap<Id, Registered>.applyDiff(other: ReadKeyValueRepo<Id, Registered>) {
+    applyDiff(diff(other))
+}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/diff/KeyValuesRepoDiff.kt

@@ -0,0 +1,33 @@
+package dev.inmo.micro_utils.repos.diff
+
+import dev.inmo.micro_utils.common.MapDiff
+import dev.inmo.micro_utils.common.applyDiff
+import dev.inmo.micro_utils.common.diff
+import dev.inmo.micro_utils.repos.*
+
+suspend fun <Id, Registered> ReadKeyValuesRepo<Id, Registered>.diff(other: Map<Id, List<Registered>>): MapDiff<Id, List<Registered>> {
+    return getAll().diff(other)
+}
+
+suspend fun <Id, Registered> Map<Id, List<Registered>>.diff(other: ReadKeyValuesRepo<Id, Registered>): MapDiff<Id, List<Registered>> {
+    return diff(other.getAll())
+}
+
+suspend fun <Id, Registered> KeyValuesRepo<Id, Registered>.applyDiff(diff: MapDiff<Id, List<Registered>>) {
+    diff.removed.forEach {
+        clear(it.key)
+    }
+    set(
+        diff.changed.map { (k, oldNew) ->
+            k to oldNew.second
+        }.toMap() + diff.added
+    )
+}
+
+suspend fun <Id, Registered> KeyValuesRepo<Id, Registered>.applyDiff(other: Map<Id, List<Registered>>) {
+    applyDiff(diff(other))
+}
+
+suspend fun <Id, Registered> MutableMap<Id, List<Registered>>.applyDiff(other: ReadKeyValuesRepo<Id, Registered>) {
+    applyDiff(diff(other))
+}

resources/build.gradle

@@ -13,9 +13,5 @@ kotlin {
                 api project(":micro_utils.language_codes")
             }
         }
-
-        androidMain {
-            dependsOn(jvmMain)
-        }
     }
 }

settings.gradle

@@ -49,6 +49,12 @@ String[] includes = [
     ":fsm:common",
     ":fsm:repos:common",
 
+    ":ksp:generator",
+
+    ":ksp:sealed",
+    ":ksp:sealed:generator",
+    ":ksp:sealed:generator:test",
+
     ":dokka"
 ]