improve selectByIds and fill changelog

0.24.3

.github/workflows/build.yml

@@ -17,8 +17,9 @@ jobs:
           mv gradle.properties.tmp gradle.properties
       - name: Build
         run: ./gradlew build
-      - name: Publish
+      - name: Publish to InmoNexus
         continue-on-error: true
-        run: ./gradlew publishAllPublicationsToGiteaRepository
+        run: ./gradlew publishAllPublicationsToInmoNexusRepository
         env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          INMONEXUS_USER: ${{ secrets.INMONEXUS_USER }}
+          INMONEXUS_PASSWORD: ${{ secrets.INMONEXUS_PASSWORD }}

CHANGELOG.md

@@ -1,5 +1,154 @@
 # Changelog
 
+## 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`:
+  * `Coroutines`: `1.9.0` -> `1.10.1`
+  * `KSLog`: `1.3.6` -> `1.4.0`
+  * `Compose`: `1.7.1` -> `1.7.3`
+  * `Ktor`: `3.0.2` -> `3.0.3`
+* `Common`:
+  * Rename `Progress` to more common `Percentage`. `Progress` now is typealias
+  * Fix of `Progress.compareTo` extension
+
+## 0.23.2
+
+* `Versions`:
+  * `Kotlin`: `2.0.21` -> `2.1.0`
+  * `Exposed`: `0.56.0` -> `0.57.0`
+  * `Xerial SQLite`: `3.47.0.0` -> `3.47.1.0`
+  * `Ktor`: `3.0.1` -> `3.0.2`
+* `Coroutines`:
+  * Small refactor in `AccumulatorFlow` to use `runCatching` instead of `runCatchingSafely`
+
+## 0.23.1
+
+* `Versions`:
+  * `Compose`: `1.7.0` -> `1.7.1`
+  * `Exposed`: `0.55.0` -> `0.56.0`
+  * `Xerial SQLite`: `3.46.1.3` -> `3.47.0.0`
+  * `Android CoreKTX`: `1.13.1` -> `1.15.0`
+  * `Android Fragment`: `1.8.4` -> `1.8.5`
+* `Coroutines`:
+  * `Compose`:
+    * Add `StyleSheetsAggregator`
+
+## 0.23.0
+
+**THIS UPDATE MAY CONTAINS SOME BREAKING CHANGES (INCLUDING BREAKING CHANGES IN BYTECODE LAYER) RELATED TO UPDATE OF
+KTOR DEPENDENCY**
+
+**THIS UPDATE CONTAINS CHANGES ACCORDING TO MIGRATION [GUIDE FROM KTOR](https://ktor.io/docs/migrating-3.html)**
+
+* `Versions`:
+  * `Ktor`: `2.3.12` -> `3.0.1`
+* `Ktor`:
+  * `Common`:
+    * Extension `Input.downloadToTempFile` has changed its receiver to `Source`. Its API can be broken
+  * `Client`:
+    * Extension `HttpClient.tempUpload` has changed type of `onUpload` argument from `OnUploadCallback` to `ProgressListener`
+    * All extensions `HttpClient.uniUpload` have changed type of `onUpload` argument from `OnUploadCallback` to `ProgressListener`
+  * `Server`:
+    * Remove redundant `ApplicationCall.respond` extension due to its presence in the ktor library
+
+## 0.22.9
+
+* `Repos`:
+  * `Cache`:
+    * Add direct caching repos
+
+## 0.22.8
+
+* `Common`:
+  * Add `List.breakAsPairs` extension
+  * Add `Sequence.padWith`/`Sequence.padStart`/`Sequence.padEnd` and `List.padWith`/`List.padStart`/`List.padEnd` extensions
+
+## 0.22.7
+
+* `Versions`:
+  * `Kotlin`: `2.0.20` -> `2.0.21`
+  * `Compose`: `1.7.0-rc01` -> `1.7.0`
+* `KSP`:
+  * `Sealed`:
+    * Change package of `GenerateSealedWorkaround`. Migration: replace `dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround` -> `dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround`
+
+## 0.22.6
+
+* `KSP`:
+  * `Generator`:
+    * Add extension `KSClassDeclaration.buildSubFileName`
+    * Add extension `KSClassDeclaration.companion`
+    * Add extension `KSClassDeclaration.resolveSubclasses`
+  * `Sealed`:
+    * Improvements
+
+## 0.22.5
+
+* `Versions`:
+  * `Compose`: `1.7.0-beta02` -> `1.7.0-rc01`
+  * `SQLite`: `3.46.1.2` -> `3.46.1.3`
+  * `AndroidXFragment`: `1.8.3` -> `1.8.4`
+* `Common`:
+  * Add extension `withReplacedAt`/`withReplaced` ([#489](https://github.com/InsanusMokrassar/MicroUtils/issues/489))
+* `Coroutines`:
+  * Add extension `Flow.debouncedBy`
+* `Ktor`:
+  * `Server`:
+    * Add `KtorApplicationConfigurator.Routing.Static` as solution for [#488](https://github.com/InsanusMokrassar/MicroUtils/issues/488)
+
+## 0.22.4
+
+* `Versions`:
+  * `Exposed`: `0.54.0` -> `0.55.0`
+  * `SQLite`: `3.46.1.0` -> `3.46.1.2`
+
+## 0.22.3
+
+* `Versions`:
+  * `Serialization`: `1.7.2` -> `1.7.3`
+  * `Coroutines`: `1.8.1` -> `1.9.0`
+  * `Compose`: `1.7.0-alpha03` -> `1.7.0-beta02`
+  * `Koin`: `3.5.6` -> `4.0.0`
+  * `Okio`: `3.9.0` -> `3.9.1`
+  * `AndroidFragment`: `1.8.2` -> `1.8.3`
+  * `androidx.compose.material3:material3` has been replaced with `org.jetbrains.compose.material3:material3`
+* `Common`:
+  * `JS`:
+    * Add several useful extensions
+  * `Compose`:
+    * `JS`:
+      * Add several useful extensions
+
 ## 0.22.2
 
 * `Versions`:

android/smalltextfield/build.gradle

@@ -12,7 +12,7 @@ kotlin {
     sourceSets {
         androidMain {
             dependencies {
-                api libs.android.compose.material3
+                api libs.jb.compose.material3
             }
         }
     }

common/compose/src/jsMain/kotlin/dev/inmo/micro_utils/common/compose/AttrBuilderContextExtensions.kt

@@ -0,0 +1,19 @@
+package dev.inmo.micro_utils.common.compose
+
+import org.jetbrains.compose.web.dom.AttrBuilderContext
+import org.w3c.dom.Element
+
+operator fun <T : Element> AttrBuilderContext<T>?.plus(
+    other: AttrBuilderContext<T>?
+) = when (this) {
+    null -> other ?: {}
+    else -> when (other) {
+        null -> this ?: {}
+        else -> {
+            {
+                invoke(this)
+                other(this)
+            }
+        }
+    }
+}

common/compose/src/jsMain/kotlin/dev/inmo/micro_utils/common/compose/MultiRef.kt

@@ -0,0 +1,22 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.DisposableEffectResult
+import androidx.compose.runtime.DisposableEffectScope
+import org.jetbrains.compose.web.attributes.AttrsScope
+import org.jetbrains.compose.web.dom.ElementScope
+import org.w3c.dom.Element
+
+/**
+ * This function must be called in the context of your tag content. It works like default [AttrsScope.ref],
+ * but able to be used several times. Uses [DisposableEffect] under the hood
+ */
+@Composable
+fun <T : Element> ElementScope<T>.ref(
+    block: DisposableEffectScope.(T) -> DisposableEffectResult
+) {
+    DisposableEffect(0) {
+        block(scopeElement)
+    }
+}

common/compose/src/jsMain/kotlin/dev/inmo/micro_utils/common/compose/TagAttributesExtensions.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.common.compose
+
+import org.jetbrains.compose.web.dom.AttrBuilderContext
+
+fun tagClasses(vararg classnames: String): AttrBuilderContext<*> = {
+    classes(*classnames)
+}
+
+fun tagId(id: String): AttrBuilderContext<*> = {
+    id(id)
+}

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

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.common
+
+fun <T> List<T>.breakAsPairs(): List<Pair<T, T>> {
+    val result = mutableListOf<Pair<T, T>>()
+
+    for (i in 0 until size - 1) {
+        val first = get(i)
+        val second = get(i + 1)
+        result.add(first to second)
+    }
+
+    return result
+}

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

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.common
+
+inline fun <T> Sequence<T>.padWith(size: Int, inserter: (Sequence<T>) -> Sequence<T>): Sequence<T> {
+    var result = this
+    while (result.count() < size) {
+        result = inserter(result)
+    }
+    return result
+}
+
+inline fun <T> Sequence<T>.padEnd(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { it + padBlock(it.count()) }
+
+inline fun <T> Sequence<T>.padEnd(size: Int, o: T) = padEnd(size) { o }
+
+inline fun <T> List<T>.padWith(size: Int, inserter: (List<T>) -> List<T>): List<T> {
+    var result = this
+    while (result.size < size) {
+        result = inserter(result)
+    }
+    return result
+}
+inline fun <T> List<T>.padEnd(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padEnd(size, padBlock).toList()
+
+inline fun <T> List<T>.padEnd(size: Int, o: T): List<T> = asSequence().padEnd(size, o).toList()
+
+inline fun <T> Sequence<T>.padStart(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { sequenceOf(padBlock(it.count())) + it }
+
+inline fun <T> Sequence<T>.padStart(size: Int, o: T) = padStart(size) { o }
+
+inline fun <T> List<T>.padStart(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padStart(size, padBlock).toList()
+
+inline fun <T> List<T>.padStart(size: Int, o: T): List<T> = asSequence().padStart(size, o).toList()

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

@@ -0,0 +1,76 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.Serializable
+import kotlin.jvm.JvmInline
+
+/**
+ * Contains [of1] as main value, where 100% of percentage is when of1 == 1
+ *
+ * @see invoke
+ * @see partOfTotal
+ * @see of100
+ */
+@Serializable
+@JvmInline
+value class Percentage private constructor(
+    /**
+     * Value of percentage. When it equals to 1, means 100%
+     */
+    val of1: Double
+) {
+    /**
+     * Same as [of1], but float (using [Double.toFloat])
+     */
+    val of1Float
+        get() = of1.toFloat()
+
+    /**
+     * Represent this percentage as common percentage where 100% is 100%
+     */
+    val of100
+        get() = of1 * 100
+
+    /**
+     * Same as [of100], but float (using [Double.toFloat])
+     */
+    val of100Float
+        get() = of100.toFloat()
+
+    /**
+     * Same as [of100], but int (using [Double.toInt])
+     */
+    val of100Int
+        get() = of100.toInt()
+
+    companion object {
+        val rangeOfValues = 0.0 .. 1.0
+
+        val START = Percentage(rangeOfValues.start)
+        val COMPLETED = Percentage(rangeOfValues.endInclusive)
+
+        operator fun invoke(of1: Double) = Percentage(of1.coerceIn(rangeOfValues))
+        operator fun invoke(part: Number, total: Number) = Percentage(
+            part.toDouble() / total.toDouble()
+        )
+        fun of1(of1: Double) = Percentage(of1 = of1)
+        fun of100(of100: Double) = Percentage(of1 = of100 / 100)
+        fun partOfTotal(part: Number, total: Number) = Percentage(part = part, total = total)
+    }
+}
+
+typealias Progress = Percentage
+
+/**
+ * Will return [this] [Progress] if [Percentage.of1] in `0 .. 1` range
+ */
+fun Progress.ensureStrictOrNull(): Progress? = if (of1 in Percentage.rangeOfValues) this else null
+/**
+ * Will return [this] [Progress] if [Percentage.of1] in `0 .. 1` range. Otherwise, will throw error
+ * [IllegalArgumentException] due to [require] failure
+ */
+fun Progress.ensureStrictOrThrow(): Progress {
+    require(of1 in Percentage.rangeOfValues) {
+        "For strict checks value of percentage must be in ${Percentage.rangeOfValues}, but actual value is $of1"
+    }
+    return this
+}

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

@@ -0,0 +1,80 @@
+@file:Suppress(
+  "RemoveRedundantCallsOfConversionMethods",
+  "RedundantVisibilityModifier",
+)
+
+package dev.inmo.micro_utils.common
+
+import kotlin.Byte
+import kotlin.Double
+import kotlin.Float
+import kotlin.Int
+import kotlin.Long
+import kotlin.Short
+import kotlin.Suppress
+
+public operator fun Percentage.plus(other: Percentage): Percentage = Percentage(of1 + other.of1)
+
+public operator fun Percentage.minus(other: Percentage): Percentage = Percentage(of1 - other.of1)
+
+public operator fun Percentage.plus(i: Byte): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Byte): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Byte): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Byte): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Byte): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.plus(i: Short): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Short): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Short): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Short): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Short): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.plus(i: Int): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Int): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Int): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Int): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Int): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.plus(i: Long): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Long): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Long): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Long): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Long): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.plus(i: Float): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Float): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Float): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Float): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Float): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.plus(i: Double): Percentage = Percentage((of1 + i).toDouble())
+
+public operator fun Percentage.minus(i: Double): Percentage = Percentage((of1 - i).toDouble())
+
+public operator fun Percentage.times(i: Double): Percentage = Percentage((of1 * i).toDouble())
+
+public operator fun Percentage.div(i: Double): Percentage = Percentage((of1 / i).toDouble())
+
+public operator fun Percentage.rem(i: Double): Percentage = Percentage((of1 % i).toDouble())
+
+public operator fun Percentage.compareTo(other: Percentage): Int = (of1.compareTo(other.of1))

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

@@ -1,37 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.serialization.Serializable
-import kotlin.jvm.JvmInline
-
-@Serializable
-@JvmInline
-value class Progress private constructor(
-    val of1: Double
-) {
-    val of1Float
-        get() = of1.toFloat()
-    val of100
-        get() = of1 * 100
-    val of100Float
-        get() = of100.toFloat()
-    val of100Int
-        get() = of100.toInt()
-
-    init {
-        require(of1 in rangeOfValues) {
-            "Progress main value should be in $rangeOfValues, but incoming value is $of1"
-        }
-    }
-
-    companion object {
-        val rangeOfValues = 0.0 .. 1.0
-
-        val START = Progress(rangeOfValues.start)
-        val COMPLETED = Progress(rangeOfValues.endInclusive)
-
-        operator fun invoke(of1: Double) = Progress(of1.coerceIn(rangeOfValues))
-        operator fun invoke(part: Number, total: Number) = Progress(
-            part.toDouble() / total.toDouble()
-        )
-    }
-}

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

@@ -1,80 +0,0 @@
-@file:Suppress(
-  "RemoveRedundantCallsOfConversionMethods",
-  "RedundantVisibilityModifier",
-)
-
-package dev.inmo.micro_utils.common
-
-import kotlin.Byte
-import kotlin.Double
-import kotlin.Float
-import kotlin.Int
-import kotlin.Long
-import kotlin.Short
-import kotlin.Suppress
-
-public operator fun Progress.plus(other: Progress): Progress = Progress(of1 + other.of1)
-
-public operator fun Progress.minus(other: Progress): Progress = Progress(of1 - other.of1)
-
-public operator fun Progress.plus(i: Byte): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Byte): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Byte): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Byte): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Byte): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Short): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Short): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Short): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Short): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Short): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Int): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Int): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Int): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Int): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Int): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Long): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Long): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Long): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Long): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Long): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Float): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Float): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Float): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Float): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Float): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.plus(i: Double): Progress = Progress((of1 + i).toDouble())
-
-public operator fun Progress.minus(i: Double): Progress = Progress((of1 - i).toDouble())
-
-public operator fun Progress.times(i: Double): Progress = Progress((of1 * i).toDouble())
-
-public operator fun Progress.div(i: Double): Progress = Progress((of1 / i).toDouble())
-
-public operator fun Progress.rem(i: Double): Progress = Progress((of1 % i).toDouble())
-
-public operator fun Progress.compareTo(other: Progress): Int = (of1 - other.of1).toInt()

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

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.common
+
+fun <T> Iterable<T>.withReplacedAt(i: Int, block: (T) -> T): List<T> = take(i) + block(elementAt(i)) + drop(i + 1)
+fun <T> Iterable<T>.withReplaced(t: T, block: (T) -> T): List<T> = withReplacedAt(indexOf(t), block)
+

common/src/commonTest/kotlin/dev/inmo/micro_utils/common/PercentageTests.kt

@@ -0,0 +1,29 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class PercentageTests {
+    @Test
+    fun testCompareTo() {
+        val step = 0.01
+
+        var i = Percentage.START.of1
+        while (i <= Percentage.COMPLETED.of1) {
+            val percentageI = Percentage(i)
+
+            var j = Percentage.START.of1
+            while (j <= Percentage.COMPLETED.of1) {
+                val percentageJ = Percentage(j)
+
+                assertEquals(percentageI.of1.compareTo(percentageJ.of1), percentageI.compareTo(percentageJ))
+                assertEquals(percentageI.of1 > percentageJ.of1, percentageI > percentageJ)
+                assertEquals(percentageI.of1 < percentageJ.of1, percentageI < percentageJ)
+
+                j += step
+            }
+
+            i += step
+        }
+    }
+}

common/src/commonTest/kotlin/dev/inmo/micro_utils/common/WithReplacedTest.kt

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class WithReplacedTest {
+    @Test
+    fun testReplaced() {
+        val data = 0 until 10
+        val testData = Int.MAX_VALUE
+
+        for (i in 0 until data.last) {
+            val withReplaced = data.withReplacedAt(i) {
+                testData
+            }
+            val dataAsMutableList = data.toMutableList()
+            dataAsMutableList[i] = testData
+            assertEquals(withReplaced, dataAsMutableList.toList())
+        }
+    }
+}

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

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

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

@@ -0,0 +1,29 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.browser.window
+import org.w3c.files.Blob
+import org.w3c.files.BlobPropertyBag
+import kotlin.js.json
+
+external class ClipboardItem(data: dynamic)
+
+inline fun Blob.convertToClipboardItem(): ClipboardItem {
+    val itemData: dynamic = json(this.type to this)
+    return ClipboardItem(itemData)
+}
+
+suspend fun copyImageURLToClipboard(imageUrl: String): Boolean {
+    return runCatching {
+        val response = window.fetch(imageUrl).await()
+        val blob = response.blob().await()
+        val data = arrayOf(
+            Blob(
+                arrayOf(blob),
+                BlobPropertyBag("image/png")
+            ).convertToClipboardItem()
+        ).asDynamic()
+        window.navigator.clipboard.write(data)
+    }.onFailure {
+        it.printStackTrace()
+    }.isSuccess
+}

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

@@ -0,0 +1,66 @@
+package dev.inmo.micro_utils.coroutines.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.remember
+import dev.inmo.micro_utils.coroutines.SpecialMutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.debounce
+import org.jetbrains.compose.web.css.CSSRulesHolder
+import org.jetbrains.compose.web.css.Style
+import org.jetbrains.compose.web.css.StyleSheet
+
+/**
+ * Aggregator of Compose CSS StyleSheet. Allowing to add [StyleSheet] in it and draw it in one place without requiring
+ * to add `Style(stylesheet)` on every compose function call
+ */
+object StyleSheetsAggregator {
+    private val _stylesFlow = SpecialMutableStateFlow<Set<CSSRulesHolder>>(emptySet())
+    val stylesFlow: StateFlow<Set<CSSRulesHolder>> = _stylesFlow.asStateFlow()
+
+    @Composable
+    fun draw() {
+        _stylesFlow.debounce(13L).collectAsState(emptySet()).value.forEach {
+            Style(it)
+        }
+    }
+
+    /**
+     * Adding [styleSheet] into the [Set] of included stylesheets. If you called [enableStyleSheetsAggregator],
+     * new styles will be enabled in the document
+     */
+    fun addStyleSheet(styleSheet: CSSRulesHolder) {
+        _stylesFlow.value += styleSheet
+    }
+
+    /**
+     * Removed [styleSheet] into the [Set] of included stylesheets
+     */
+    fun removeStyleSheet(styleSheet: CSSRulesHolder) {
+        _stylesFlow.value -= styleSheet
+    }
+}
+
+/**
+ * Drawing [StyleSheetsAggregator] in place. You may pass [Set] of [CSSRulesHolder]/[StyleSheet]s as preset of styles
+ */
+@Composable
+fun enableStyleSheetsAggregator(
+    stylesPreset: Set<CSSRulesHolder> = emptySet(),
+) {
+    remember {
+        stylesPreset.forEach {
+            StyleSheetsAggregator.addStyleSheet(it)
+        }
+    }
+    StyleSheetsAggregator.draw()
+}
+
+/**
+ * Will include [this] [CSSRulesHolder]/[StyleSheet] in the [StyleSheetsAggregator] using its
+ * [StyleSheetsAggregator.addStyleSheet]
+ */
+fun CSSRulesHolder.includeInStyleSheetsAggregator() {
+    StyleSheetsAggregator.addStyleSheet(this)
+}

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

@@ -68,9 +68,9 @@ class AccumulatorFlow<T>(
     override suspend fun collectSafely(collector: FlowCollector<T>) {
         val channel = Channel<T>(Channel.UNLIMITED, BufferOverflow.SUSPEND)
         steps.send(SubscribeAccumulatorFlowStep(channel))
-        val result = runCatchingSafely {
+        val result = runCatching {
             for (data in channel) {
-                val emitResult = runCatchingSafely {
+                val emitResult = runCatching {
                     collector.emit(data)
                 }
                 if (emitResult.isSuccess || emitResult.exceptionOrNull() is CancellationException) {

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

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.jvm.JvmInline
+import kotlin.time.Duration
+
+@JvmInline
+private value class DebouncedByData<T>(
+    val millisToData: Pair<Long, T>
+)
+
+fun <T> Flow<T>.debouncedBy(timeout: (T) -> Long, markerFactory: (T) -> Any?): Flow<T> = channelFlow {
+    val jobs = mutableMapOf<Any?, Job>()
+    val mutex = Mutex()
+    subscribe(this) {
+        mutex.withLock {
+            val marker = markerFactory(it)
+            lateinit var job: Job
+            job = async {
+                delay(timeout(it))
+                mutex.withLock {
+                    if (jobs[marker] === job) {
+                        this@channelFlow.send(it)
+                        jobs.remove(marker)
+                    }
+                }
+            }
+            jobs[marker] ?.cancel()
+            jobs[marker] = job
+        }
+    }
+}
+
+fun <T> Flow<T>.debouncedBy(timeout: Long, markerFactory: (T) -> Any?): Flow<T> = debouncedBy({ timeout }, markerFactory)
+fun <T> Flow<T>.debouncedBy(timeout: Duration, markerFactory: (T) -> Any?): Flow<T> = debouncedBy({ timeout.inWholeMilliseconds }, markerFactory)

coroutines/src/commonTest/kotlin/DebouncedByTests.kt

@@ -0,0 +1,42 @@
+import dev.inmo.micro_utils.coroutines.debouncedBy
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class DebouncedByTests {
+    @Test
+    fun testThatParallelDebouncingWorksCorrectly() = runTest {
+        val dataToMarkerFactories = listOf(
+            1 to 0,
+            2 to 1,
+            3 to 2,
+            4 to 0,
+            5 to 1,
+            6 to 2,
+            7 to 0,
+            8 to 1,
+            9 to 2,
+        )
+
+        val collected = mutableListOf<Int>()
+
+        dataToMarkerFactories.asFlow().debouncedBy(10L) {
+            it.second
+        }.collect {
+            when (it.second) {
+                0 -> assertEquals(7, it.first)
+                1 -> assertEquals(8, it.first)
+                2 -> assertEquals(9, it.first)
+                else -> error("wtf")
+            }
+            collected.add(it.first)
+        }
+
+        val expectedList = listOf(7, 8, 9)
+        assertEquals(expectedList, collected)
+        assertTrue { collected.containsAll(expectedList) }
+        assertTrue { expectedList.containsAll(collected) }
+    }
+}

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 {

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.22.2
-android_code_version=268
+version=0.24.4
+android_code_version=283

gradle/libs.versions.toml

@@ -1,29 +1,29 @@
 [versions]
 
-kt = "2.0.20"
-kt-serialization = "1.7.2"
-kt-coroutines = "1.8.1"
+kt = "2.1.0"
+kt-serialization = "1.8.0"
+kt-coroutines = "1.10.1"
 
-kslog = "1.3.6"
+kslog = "1.4.0"
 
-jb-compose = "1.7.0-alpha03"
-jb-exposed = "0.54.0"
-jb-dokka = "1.9.20"
+jb-compose = "1.7.3"
+jb-exposed = "0.58.0"
+jb-dokka = "2.0.0"
 
-sqlite = "3.46.1.0"
+sqlite = "3.47.2.0"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "2.3.12"
+ktor = "3.0.3"
 
 gh-release = "2.5.2"
 
-koin = "3.5.6"
+koin = "4.0.1"
 
-okio = "3.9.0"
+okio = "3.10.2"
 
-ksp = "2.0.20-1.0.24"
+ksp = "2.1.0-1.0.29"
 kotlin-poet = "1.18.1"
 
 versions = "0.51.0"
@@ -31,13 +31,13 @@ versions = "0.51.0"
 android-gradle = "8.2.2"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.13.1"
+android-coreKtx = "1.15.0"
 android-recyclerView = "1.3.2"
 android-appCompat = "1.7.0"
-android-fragment = "1.8.2"
+android-fragment = "1.8.5"
 android-espresso = "3.6.1"
 android-test = "1.2.1"
-android-compose-material3 = "1.2.1"
+android-compose-material3 = "1.3.0"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "35"
@@ -85,11 +85,11 @@ jb-exposed = { module = "org.jetbrains.exposed:exposed-core", version.ref = "jb-
 jb-exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "jb-exposed" }
 sqlite = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" }
 
+jb-compose-material3 = { module = "org.jetbrains.compose.material3:material3", version.ref = "jb-compose" }
 
 android-coreKtx = { module = "androidx.core:core-ktx", version.ref = "android-coreKtx" }
 android-recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "android-recyclerView" }
 android-appCompat-resources = { module = "androidx.appcompat:appcompat-resources", version.ref = "android-appCompat" }
-android-compose-material3 = { module = "androidx.compose.material3:material3", version.ref = "android-compose-material3" }
 android-fragment = { module = "androidx.fragment:fragment", version.ref = "android-fragment" }
 android-espresso = { module = "androidx.test.espresso:espresso-core", version.ref = "android-espresso" }
 android-test-junit = { module = "androidx.test.ext:junit", version.ref = "android-test" }

gradle/wrapper/gradle-wrapper.properties

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

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

@@ -0,0 +1,13 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+val KSClassDeclaration.buildSubFileName: String
+    get() {
+        val parentDeclarationCaptured = parentDeclaration
+        val simpleNameString = simpleName.asString()
+        return when (parentDeclarationCaptured) {
+            is KSClassDeclaration -> parentDeclarationCaptured.buildSubFileName
+            else -> ""
+        } + simpleNameString
+    }

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

@@ -0,0 +1,8 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+val KSClassDeclaration.companion
+    get() = declarations.firstNotNullOfOrNull {
+        (it as? KSClassDeclaration)?.takeIf { it.isCompanionObject }
+    }

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

@@ -0,0 +1,11 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+fun KSClassDeclaration.resolveSubclasses(): List<KSClassDeclaration> {
+    return (getSealedSubclasses().flatMap {
+        it.resolveSubclasses()
+    }.ifEmpty {
+        sequenceOf(this)
+    }).toList()
+}

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

@@ -0,0 +1,17 @@
+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,19 +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.microutils.kps.sealed.GenerateSealedWorkaround
+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
@@ -51,10 +49,10 @@ class Processor(
         ksClassDeclaration: KSClassDeclaration,
         resolver: Resolver
     ) {
-        val annotation = ksClassDeclaration.getAnnotationsByType(GenerateSealedWorkaround::class).first()
+        val annotation = ksClassDeclaration.getGenerateSealedWorkaroundAnnotation
         val subClasses = ksClassDeclaration.resolveSubclasses(
             searchIn = resolver.getAllFiles(),
-            allowNonSealed = annotation.includeNonSealedSubTypes
+            allowNonSealed = annotation ?.includeNonSealedSubTypes ?: false
         ).distinct()
         val subClassesNames = subClasses.filter {
             when (it.classKind) {
@@ -93,7 +91,10 @@ class Processor(
         )
         addFunction(
             FunSpec.builder("values").apply {
-                receiver(ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion"))
+                val companion = ksClassDeclaration.takeIf { it.isCompanionObject } ?.toClassName()
+                    ?: ksClassDeclaration.companion ?.toClassName()
+                    ?: ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion")
+                receiver(companion)
                 returns(setType)
                 addCode(
                     CodeBlock.of(
@@ -104,10 +105,68 @@ 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 {
-            val prefix = it.getAnnotationsByType(GenerateSealedWorkaround::class).first().prefix
+            val prefix = (it.getGenerateSealedWorkaroundAnnotation) ?.prefix ?.takeIf {
+                it.isNotEmpty()
+            } ?: it.buildSubFileName.replaceFirst(it.simpleName.asString(), "")
             it.writeFile(prefix = prefix, suffix = "SealedWorkaround") {
                 FileSpec.builder(
                     it.packageName.asString(),
@@ -124,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/src/commonMain/kotlin/Test.kt

@@ -1,14 +1,19 @@
 package dev.inmo.micro_utils.ksp.sealed.generator.test
 
-import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround
+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

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

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

@@ -0,0 +1,6 @@
+package dev.inmo.microutils.kps.sealed
+
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
+
+@Deprecated("Replaced", ReplaceWith("GenerateSealedWorkaround", "dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround"))
+typealias GenerateSealedWorkaround = GenerateSealedWorkaround

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

@@ -3,9 +3,10 @@ package dev.inmo.micro_utils.ktor.client
 import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 
 expect suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback = { _, _ -> }
+    onUpload: ProgressListener = ProgressListener { _, _ -> }
 ): TemporalFileId

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

@@ -4,8 +4,8 @@ import dev.inmo.micro_utils.common.FileName
 import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.ktor.common.LambdaInputProvider
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.http.Headers
-import io.ktor.utils.io.core.Input
 import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.StringFormat
 import kotlinx.serialization.json.Json
@@ -31,7 +31,7 @@ expect suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: OnUploadCallback = { _, _ -> }
+    onUpload: ProgressListener = ProgressListener { _, _ -> }
 ): T?
 
 /**
@@ -46,7 +46,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: OnUploadCallback = { _, _ -> }
+    onUpload: ProgressListener = ProgressListener { _, _ -> }
 ): T? = uniUpload(
     url,
     additionalData + ("bytes" to file),
@@ -68,7 +68,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: OnUploadCallback = { _, _ -> }
+    onUpload: ProgressListener = ProgressListener { _, _ -> }
 ): T? = uniUpload(
     url,
     additionalData + ("bytes" to info),
@@ -93,7 +93,7 @@ suspend fun <T> HttpClient.uniUpload(
     additionalData: Map<String, Any> = emptyMap(),
     headers: Headers = Headers.Empty,
     stringFormat: StringFormat = Json,
-    onUpload: OnUploadCallback = { _, _ -> }
+    onUpload: ProgressListener = ProgressListener { _, _ -> }
 ): T? = uniUpload(
     url,
     UniUploadFileInfo(fileName, mimeType, inputAllocator),

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

@@ -5,16 +5,15 @@ import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
 import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import kotlinx.coroutines.*
-import org.w3c.dom.mediasource.ENDED
-import org.w3c.dom.mediasource.ReadyState
 import org.w3c.xhr.*
 import org.w3c.xhr.XMLHttpRequest.Companion.DONE
 
 suspend fun tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId {
     val formData = FormData()
     val answer = CompletableDeferred<TemporalFileId>(currentCoroutineContext().job)
@@ -28,7 +27,7 @@ suspend fun tempUpload(
     val request = XMLHttpRequest()
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {
@@ -60,5 +59,5 @@ suspend fun tempUpload(
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId = dev.inmo.micro_utils.ktor.client.tempUpload(fullTempUploadDraftPath, file, onUpload)

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

@@ -1,10 +1,10 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.common.Progress
 import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
 import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.http.Headers
 import io.ktor.utils.io.core.readBytes
 import kotlinx.coroutines.CompletableDeferred
@@ -36,7 +36,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): T? {
     val formData = FormData()
     val answer = CompletableDeferred<T?>(currentCoroutineContext().job)
@@ -66,7 +66,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     }
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
+        subscope.launchSafelyWithoutExceptions { onUpload.onProgress(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {

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

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.common.MPPFile
 import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -18,7 +19,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

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

@@ -1,8 +1,7 @@
 package dev.inmo.micro_utils.ktor.client
 
-import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.client.request.forms.InputProvider
@@ -20,7 +19,6 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 import java.io.File
 
@@ -39,7 +37,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): T? {
     val withBinary = data.values.any { it is File || it is UniUploadFileInfo }
 
@@ -76,7 +74,7 @@ actual suspend fun <T> HttpClient.uniUpload(
             appendAll(headers)
         }
         onUpload { bytesSentTotal, contentLength ->
-            onUpload(bytesSentTotal, contentLength)
+            onUpload.onProgress(bytesSentTotal, contentLength)
         }
     }
 

ktor/client/src/linuxArm64Main/kotlin/ActualTemporalUpload.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -18,7 +19,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/linuxArm64Main/kotlin/ActualUniUpload.kt

@@ -1,9 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.client.request.forms.InputProvider
@@ -21,7 +20,6 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -39,7 +37,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -75,9 +73,7 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload { bytesSentTotal, contentLength ->
-            onUpload(bytesSentTotal, contentLength)
-        }
+        onUpload(onUpload)
     }
 
     val response = if (withBinary) {

ktor/client/src/linuxX64Main/kotlin/ActualTemporalUpload.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -18,7 +19,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/linuxX64Main/kotlin/ActualUniUpload.kt

@@ -1,9 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.client.request.forms.InputProvider
@@ -21,7 +20,6 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -39,7 +37,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -75,9 +73,7 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload { bytesSentTotal, contentLength ->
-            onUpload(bytesSentTotal, contentLength)
-        }
+        onUpload(onUpload)
     }
 
     val response = if (withBinary) {

ktor/client/src/mingwX64Main/kotlin/ActualTemporalUpload.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
 import io.ktor.client.HttpClient
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.forms.formData
 import io.ktor.client.request.forms.submitFormWithBinaryData
@@ -18,7 +19,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

ktor/client/src/mingwX64Main/kotlin/ActualUniUpload.kt

@@ -1,9 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
-import dev.inmo.micro_utils.common.Progress
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.content.*
 import io.ktor.client.plugins.onUpload
 import io.ktor.client.request.HttpRequestBuilder
 import io.ktor.client.request.forms.InputProvider
@@ -21,7 +20,6 @@ import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.serializer
 
 /**
@@ -39,7 +37,7 @@ actual suspend fun <T> HttpClient.uniUpload(
     resultDeserializer: DeserializationStrategy<T>,
     headers: Headers,
     stringFormat: StringFormat,
-    onUpload: OnUploadCallback
+    onUpload: ProgressListener
 ): T? {
     val withBinary = data.values.any { it is MPPFile || it is UniUploadFileInfo }
 
@@ -75,9 +73,7 @@ actual suspend fun <T> HttpClient.uniUpload(
         headers {
             appendAll(headers)
         }
-        onUpload { bytesSentTotal, contentLength ->
-            onUpload(bytesSentTotal, contentLength)
-        }
+        onUpload(onUpload)
     }
 
     val response = if (withBinary) {

ktor/common/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/common/CreateTempFileFromInput.kt

@@ -1,13 +1,12 @@
 package dev.inmo.micro_utils.ktor.common
 
-import io.ktor.utils.io.core.Input
-import io.ktor.utils.io.core.copyTo
-import io.ktor.utils.io.streams.asOutput
+import io.ktor.utils.io.streams.*
+import kotlinx.io.Source
+import kotlinx.io.readTo
 import java.io.File
-import java.io.InputStream
 import java.util.UUID
 
-fun Input.downloadToTempFile(
+fun Source.downloadToTempFile(
     fileName: String = UUID.randomUUID().toString(),
     fileExtension: String? = ".temp",
     folder: File? = null
@@ -17,7 +16,7 @@ fun Input.downloadToTempFile(
     folder
 ).apply {
     outputStream().use {
-        copyTo(it.asOutput())
+        it.writePacket(this@downloadToTempFile)
     }
     deleteOnExit()
 }

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

@@ -1,15 +0,0 @@
-package dev.inmo.micro_utils.ktor.server
-
-import io.ktor.server.application.ApplicationCall
-import io.ktor.server.response.responseType
-import io.ktor.util.InternalAPI
-import io.ktor.util.reflect.TypeInfo
-
-@InternalAPI
-suspend fun <T : Any> ApplicationCall.respond(
-    message: T,
-    typeInfo: TypeInfo
-) {
-    response.responseType = typeInfo
-    response.pipeline.execute(this, message as Any)
-}

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

@@ -4,13 +4,13 @@ import com.benasher44.uuid.uuid4
 import io.ktor.http.content.PartData
 import io.ktor.utils.io.copyTo
 import io.ktor.utils.io.core.copyTo
-import io.ktor.utils.io.jvm.javaio.copyTo
-import io.ktor.utils.io.streams.asOutput
+import io.ktor.utils.io.jvm.javaio.*
+import io.ktor.utils.io.streams.*
 import java.io.File
 
 fun PartData.FileItem.download(target: File) {
-    provider().use { input ->
-        target.outputStream().asOutput().use {
+    provider().toInputStream().use { input ->
+        target.outputStream().use {
             input.copyTo(it)
         }
     }
@@ -25,9 +25,9 @@ fun PartData.FileItem.downloadToTemporalFile(): File {
 }
 
 fun PartData.BinaryItem.download(target: File) {
-    provider().use { input ->
+    provider().inputStream().use { input ->
         target.outputStream().use {
-            input.copyTo(it.asOutput())
+            input.copyTo(it)
         }
     }
 }

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.ktor.server
 
 import dev.inmo.micro_utils.ktor.server.configurators.KtorApplicationConfigurator
-import io.ktor.server.application.Application
+import io.ktor.server.application.*
 import io.ktor.server.cio.CIO
 import io.ktor.server.cio.CIOApplicationEngine
 import io.ktor.server.engine.*
@@ -11,20 +11,22 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
     engine: ApplicationEngineFactory<TEngine, TConfiguration>,
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
+    environment: ApplicationEnvironment = applicationEnvironment(),
     block: Application.() -> Unit
-): TEngine = embeddedServer(
+): EmbeddedServer<TEngine, TConfiguration> = embeddedServer<TEngine, TConfiguration>(
     engine,
-    applicationEngineEnvironment {
-        module(block)
+    environment,
+    {
         connector {
             this.host = host
             this.port = port
+            additionalEngineEnvironmentConfigurator()
         }
-        additionalEngineEnvironmentConfigurator()
+        additionalConfigurationConfigurator()
     },
-    additionalConfigurationConfigurator
+    module = block
 )
 
 /**
@@ -35,15 +37,17 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
 fun createKtorServer(
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
+    environment: ApplicationEnvironment = applicationEnvironment(),
     block: Application.() -> Unit
-): CIOApplicationEngine = createKtorServer(
+): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> = createKtorServer(
     CIO,
     host,
     port,
     additionalEngineEnvironmentConfigurator,
     additionalConfigurationConfigurator,
+    environment,
     block
 )
 
@@ -51,15 +55,17 @@ fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configurati
     engine: ApplicationEngineFactory<TEngine, TConfiguration>,
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
-    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: TConfiguration.() -> Unit = {},
+    environment: ApplicationEnvironment = applicationEnvironment(),
     configurators: List<KtorApplicationConfigurator>
-): TEngine = createKtorServer(
+): EmbeddedServer<TEngine, TConfiguration> = createKtorServer(
     engine,
     host,
     port,
     additionalEngineEnvironmentConfigurator,
-    additionalConfigurationConfigurator
+    additionalConfigurationConfigurator,
+    environment,
 ) {
     configurators.forEach { it.apply { configure() } }
 }
@@ -73,6 +79,7 @@ fun createKtorServer(
     host: String = "localhost",
     port: Int = Random.nextInt(1024, 65535),
     configurators: List<KtorApplicationConfigurator>,
-    additionalEngineEnvironmentConfigurator: ApplicationEngineEnvironmentBuilder.() -> Unit = {},
+    additionalEngineEnvironmentConfigurator: EngineConnectorBuilder.() -> Unit = {},
     additionalConfigurationConfigurator: CIOApplicationEngine.Configuration.() -> Unit = {},
-): ApplicationEngine = createKtorServer(CIO, host, port, additionalEngineEnvironmentConfigurator, additionalConfigurationConfigurator, configurators)
+    environment: ApplicationEnvironment = applicationEnvironment(),
+): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> = createKtorServer(CIO, host, port, additionalEngineEnvironmentConfigurator, additionalConfigurationConfigurator, environment, configurators)

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

@@ -17,6 +17,7 @@ import io.ktor.server.response.respondText
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.post
 import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -26,7 +27,10 @@ import java.nio.file.attribute.FileTime
 
 class TemporalFilesRoutingConfigurator(
     private val subpath: String = DefaultTemporalFilesSubPath,
-    private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer
+    private val temporalFilesUtilizer: TemporalFilesUtilizer = TemporalFilesUtilizer,
+    filesFlowReplay: Int = 0,
+    filesFlowExtraBufferCapacity: Int = Int.MAX_VALUE,
+    filesFlowOnBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
 ) : ApplicationRoutingConfigurator.Element {
     interface TemporalFilesUtilizer {
         fun start(filesMap: MutableMap<TemporalFileId, MPPFile>, filesMutex: Mutex, onNewFileFlow: Flow<TemporalFileId>): Job
@@ -74,7 +78,11 @@ class TemporalFilesRoutingConfigurator(
 
     private val temporalFilesMap = mutableMapOf<TemporalFileId, MPPFile>()
     private val temporalFilesMutex = Mutex()
-    private val filesFlow = MutableSharedFlow<TemporalFileId>()
+    private val filesFlow = MutableSharedFlow<TemporalFileId>(
+        replay = filesFlowReplay,
+        extraBufferCapacity = filesFlowExtraBufferCapacity,
+        onBufferOverflow = filesFlowOnBufferOverflow
+    )
     val utilizerJob = temporalFilesUtilizer.start(temporalFilesMap, temporalFilesMutex, filesFlow.asSharedFlow())
 
     override fun Route.invoke() {
@@ -111,7 +119,7 @@ class TemporalFilesRoutingConfigurator(
                     temporalFilesMap[fileId] = file
                 }
                 call.respondText(fileId.string)
-                launchSafelyWithoutExceptions { filesFlow.emit(fileId) }
+                filesFlow.emit(fileId)
             } ?: call.respond(HttpStatusCode.BadRequest)
         }
     }

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

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.ktor.common.downloadToTempFile
 import io.ktor.http.content.*
 import io.ktor.server.application.ApplicationCall
 import io.ktor.server.request.receiveMultipart
+import io.ktor.utils.io.*
 import io.ktor.utils.io.core.*
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.isActive
@@ -47,7 +48,7 @@ suspend fun ApplicationCall.uniloadMultipart(
         onBinaryChannelItem
     ) {
         when (it.name) {
-            "bytes" -> resultInput = it.provider()
+            "bytes" -> resultInput = it.provider().readBuffer()
             else -> onCustomFileItem(it)
         }
     }

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/configurators/ApplicationRoutingConfigurator.kt

@@ -2,8 +2,7 @@ package dev.inmo.micro_utils.ktor.server.configurators
 
 import dev.inmo.micro_utils.ktor.server.configurators.ApplicationRoutingConfigurator.Element
 import io.ktor.server.application.*
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.Routing
+import io.ktor.server.routing.*
 import kotlinx.serialization.Contextual
 import kotlinx.serialization.Serializable
 
@@ -19,9 +18,7 @@ class ApplicationRoutingConfigurator(
     }
 
     override fun Application.configure() {
-        pluginOrNull(Routing) ?.apply {
-            rootInstaller.apply { invoke() }
-        } ?: install(Routing) {
+        routing {
             rootInstaller.apply { invoke() }
         }
     }

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/configurators/KtorApplicationConfigurator.kt

@@ -1,7 +1,99 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.server.application.Application
+import io.ktor.server.application.*
+import io.ktor.server.http.content.*
+import io.ktor.server.plugins.cachingheaders.*
+import io.ktor.server.plugins.statuspages.*
+import io.ktor.server.routing.*
+import io.ktor.server.sessions.*
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import java.io.File
 
 interface KtorApplicationConfigurator {
+    @Serializable
+    class Routing(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun Route.invoke() }
+        private val rootInstaller = Element {
+            elements.forEach {
+                it.apply { invoke() }
+            }
+        }
+
+        override fun Application.configure() {
+            routing {
+                rootInstaller.apply { invoke() }
+            }
+        }
+
+        /**
+         * @param pathToFolder Contains [Pair]s where firsts are paths in urls and seconds are folders file paths
+         * @param pathToResource Contains [Pair]s where firsts are paths in urls and seconds are packages in resources
+         */
+        class Static(
+            private val pathToFolder: List<Pair<String, String>> = emptyList(),
+            private val pathToResource: List<Pair<String, String>> = emptyList(),
+        ) : Element {
+            override fun Route.invoke() {
+                pathToFolder.forEach {
+                    staticFiles(
+                        it.first,
+                        File(it.second)
+                    )
+                }
+                pathToResource.forEach {
+                    staticResources(
+                        it.first,
+                        it.second
+                    )
+                }
+            }
+        }
+    }
+
+    class StatusPages(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun StatusPagesConfig.invoke() }
+
+        override fun Application.configure() {
+            install(StatusPages) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
+    class Sessions(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun SessionsConfig.invoke() }
+
+        override fun Application.configure() {
+            install(Sessions) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
+    class CachingHeaders(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun CachingHeadersConfig.invoke() }
+
+        override fun Application.configure() {
+            install(CachingHeaders) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
     fun Application.configure()
 }

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/direct/DirectFullCRUDCacheRepo.kt

@@ -0,0 +1,113 @@
+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.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.cache.*
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import kotlinx.coroutines.CoroutineScope
+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 idGetter: (ObjectType) -> IdType
+) : ReadCRUDRepo<ObjectType, IdType>, DirectFullCacheRepo {
+    protected open suspend fun actualizeAll() {
+        kvCache.actualizeAll(parentRepo, locker = locker)
+    }
+
+    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = locker.withReadAcquire {
+        kvCache.values(pagination)
+    }
+
+    override suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType> = locker.withReadAcquire {
+        kvCache.keys(pagination)
+    }
+
+    override suspend fun count(): Long = locker.withReadAcquire {
+        kvCache.count()
+    }
+
+    override suspend fun contains(id: IdType): Boolean = locker.withReadAcquire {
+        kvCache.contains(id)
+    }
+
+    override suspend fun getAll(): Map<IdType, ObjectType> = locker.withReadAcquire {
+        kvCache.getAll()
+    }
+
+    override suspend fun getById(id: IdType): ObjectType? = locker.withReadAcquire {
+        kvCache.get(id)
+    }
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}
+
+fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.directlyCached(
+    kvCache: KeyValueRepo<IdType, ObjectType>,
+    locker: SmartRWLocker = SmartRWLocker(),
+    idGetter: (ObjectType) -> IdType
+) = DirectFullReadCRUDCacheRepo(this, kvCache, locker, idGetter)
+
+open class DirectFullCRUDCacheRepo<ObjectType, IdType, InputValueType>(
+    override val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    kvCache: KeyValueRepo<IdType, ObjectType>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+    idGetter: (ObjectType) -> IdType
+) : DirectFullReadCRUDCacheRepo<ObjectType, IdType>(
+    parentRepo,
+    kvCache,
+    locker,
+    idGetter
+),
+    WriteCRUDRepo<ObjectType, IdType, InputValueType> by WriteCRUDCacheRepo(
+        parentRepo,
+        kvCache,
+        scope,
+        locker,
+        idGetter
+    ),
+    CRUDRepo<ObjectType, IdType, InputValueType> {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions {
+                if (locker.writeMutex.isLocked) {
+                    initialInvalidate()
+                } else {
+                    invalidate()
+                }
+            }
+        }
+    }
+
+    protected open suspend fun initialInvalidate() {
+        try {
+            kvCache.actualizeAll(parentRepo, locker = null)
+        } finally {
+            locker.unlockWrite()
+        }
+    }
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}
+
+fun <ObjectType, IdType, InputType> CRUDRepo<ObjectType, IdType, InputType>.directFullyCached(
+    kvCache: KeyValueRepo<IdType, ObjectType> = MapKeyValueRepo(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker(),
+    idGetter: (ObjectType) -> IdType
+) = DirectFullCRUDCacheRepo(this, kvCache, scope, skipStartInvalidate, locker, idGetter)

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

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.repos.cache.full.direct
+
+import dev.inmo.micro_utils.repos.cache.full.FullCacheRepo
+
+/**
+ * Repos-inheritors MUST realize their methods via next logic:
+ *
+ * * Reloading of data in cache must be reactive (e.g. via Flow) or direct mutation methods usage (override set and
+ * mutate cache inside, for example)
+ * * All reading methods must take data from cache via synchronization with [dev.inmo.micro_utils.coroutines.SmartRWLocker]
+ */
+interface DirectFullCacheRepo : FullCacheRepo {
+}

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

@@ -0,0 +1,177 @@
+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.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.cache.full.FullKeyValueCacheRepo
+import dev.inmo.micro_utils.repos.cache.full.FullReadKeyValueCacheRepo
+import dev.inmo.micro_utils.repos.cache.full.FullWriteKeyValueCacheRepo
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.launchIn
+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()
+) : DirectFullCacheRepo, ReadKeyValueRepo<Key, Value> {
+    protected open suspend fun actualizeAll() {
+        kvCache.actualizeAll(parentRepo, locker)
+    }
+
+    override suspend fun get(k: Key): Value? = locker.withReadAcquire {
+        kvCache.get(k)
+    }
+
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = locker.withReadAcquire {
+        kvCache.values(pagination, reversed)
+    }
+
+    override suspend fun count(): Long = locker.withReadAcquire {
+        kvCache.count()
+    }
+
+    override suspend fun contains(key: Key): Boolean = locker.withReadAcquire {
+        kvCache.contains(key)
+    }
+
+    override suspend fun getAll(): Map<Key, Value> = locker.withReadAcquire {
+        kvCache.getAll()
+    }
+
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = locker.withReadAcquire {
+        kvCache.keys(pagination, reversed)
+    }
+
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = locker.withReadAcquire {
+        kvCache.keys(v, pagination, reversed)
+    }
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}
+
+fun <Key, Value> ReadKeyValueRepo<Key, Value>.directlyCached(
+    kvCache: KeyValueRepo<Key, Value>,
+    locker: SmartRWLocker = SmartRWLocker()
+) = DirectFullReadKeyValueCacheRepo(this, kvCache, locker)
+
+open class DirectFullWriteKeyValueCacheRepo<Key, Value>(
+    protected open val parentRepo: WriteKeyValueRepo<Key, Value>,
+    protected open val kvCache: KeyValueRepo<Key, Value>,
+    protected val locker: SmartRWLocker = SmartRWLocker(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+) : DirectFullCacheRepo, WriteKeyValueRepo<Key, Value> by parentRepo {
+    override val onNewValue: Flow<Pair<Key, Value>>
+        get() = parentRepo.onNewValue
+    override val onValueRemoved: Flow<Key>
+        get() = parentRepo.onValueRemoved
+
+    protected val onNewJob = parentRepo.onNewValue.onEach {
+        locker.withWriteLock {
+            kvCache.set(it.first, it.second)
+        }
+    }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
+        locker.withWriteLock {
+            kvCache.unset(it)
+        }
+    }.launchIn(scope)
+
+    override suspend fun invalidate() {
+        locker.withWriteLock {
+            kvCache.clear()
+        }
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
+}
+
+fun <Key, Value> WriteKeyValueRepo<Key, Value>.directlyCached(
+    kvCache: KeyValueRepo<Key, Value>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) = DirectFullWriteKeyValueCacheRepo(this, kvCache, scope = scope)
+
+open class DirectFullKeyValueCacheRepo<Key, Value>(
+    override val parentRepo: KeyValueRepo<Key, Value>,
+    kvCache: KeyValueRepo<Key, Value>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+) : DirectFullCacheRepo,
+    KeyValueRepo<Key, Value> ,
+    WriteKeyValueRepo<Key, Value> by DirectFullWriteKeyValueCacheRepo(
+        parentRepo,
+        kvCache,
+        locker,
+        scope
+    ),
+    DirectFullReadKeyValueCacheRepo<Key, Value>(parentRepo, kvCache, locker) {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions {
+                if (locker.writeMutex.isLocked) {
+                    initialInvalidate()
+                } else {
+                    invalidate()
+                }
+            }
+        }
+    }
+
+
+    protected open suspend fun initialInvalidate() {
+        try {
+            kvCache.actualizeAll(parentRepo, locker = null)
+        } finally {
+            locker.unlockWrite()
+        }
+    }
+    override suspend fun invalidate() {
+        kvCache.actualizeAll(parentRepo, locker)
+    }
+
+    override suspend fun clear() {
+        parentRepo.clear()
+        kvCache.clear()
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) = parentRepo.unsetWithValues(toUnset)
+
+    override suspend fun set(toSet: Map<Key, Value>) {
+        locker.withWriteLock {
+            parentRepo.set(toSet)
+            kvCache.set(
+                toSet.filter {
+                    parentRepo.contains(it.key)
+                }
+            )
+        }
+    }
+
+    override suspend fun unset(toUnset: List<Key>) {
+        locker.withWriteLock {
+            parentRepo.unset(toUnset)
+            kvCache.unset(
+                toUnset.filter {
+                    !parentRepo.contains(it)
+                }
+            )
+        }
+    }
+}
+
+fun <Key, Value> KeyValueRepo<Key, Value>.directlyFullyCached(
+    kvCache: KeyValueRepo<Key, Value> = MapKeyValueRepo(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker()
+) = DirectFullKeyValueCacheRepo(this, kvCache, scope, skipStartInvalidate, locker)

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

@@ -0,0 +1,243 @@
+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.withReadAcquire
+import dev.inmo.micro_utils.coroutines.withWriteLock
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.*
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.cache.util.ActualizeAllClearMode
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+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(),
+) : ReadKeyValuesRepo<Key, Value>, DirectFullCacheRepo {
+    protected open suspend fun actualizeKey(k: Key) {
+        kvCache.actualizeAll(locker = locker, clearMode = ActualizeAllClearMode.Never) {
+            mapOf(k to parentRepo.getAll(k))
+        }
+    }
+
+    protected open suspend fun actualizeAll() {
+        kvCache.actualizeAll(parentRepo, locker = locker)
+    }
+
+    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
+        return locker.withReadAcquire {
+            kvCache.get(k) ?.paginate(
+                pagination.let { if (reversed) it.reverse(count(k)) else it }
+            ) ?.let {
+                if (reversed) it.copy(results = it.results.reversed()) else it
+            }
+        } ?: emptyPaginationResult()
+    }
+
+    override suspend fun getAll(k: Key, reversed: Boolean): List<Value> {
+        return locker.withReadAcquire {
+            kvCache.get(k) ?.optionallyReverse(reversed)
+        } ?: emptyList()
+    }
+
+    override suspend fun getAll(reverseLists: Boolean): Map<Key, List<Value>> {
+        return locker.withReadAcquire {
+            kvCache.getAll().takeIf { it.isNotEmpty() } ?.let {
+                if (reverseLists) {
+                    it.mapValues { it.value.reversed() }
+                } else {
+                    it
+                }
+            }
+        } ?: emptyMap()
+    }
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
+        return locker.withReadAcquire {
+            kvCache.keys(pagination, reversed).takeIf { it.results.isNotEmpty() }
+        } ?: emptyPaginationResult()
+    }
+
+    override suspend fun count(): Long = locker.withReadAcquire { kvCache.count() }
+
+    override suspend fun count(k: Key): Long = locker.withReadAcquire { kvCache.get(k) ?.size } ?.toLong() ?: 0L
+
+    override suspend fun contains(k: Key, v: Value): Boolean = locker.withReadAcquire { kvCache.get(k) ?.contains(v) } == true
+
+    override suspend fun contains(k: Key): Boolean = locker.withReadAcquire { kvCache.contains(k) }
+
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> {
+        val keys = locker.withReadAcquire {
+            getAllWithNextPaging { kvCache.keys(it) }.filter { kvCache.get(it)?.contains(v) == true }
+                .optionallyReverse(reversed)
+        }
+        val result = if (keys.isNotEmpty()) {
+            keys.paginate(pagination.optionallyReverse(keys.size, reversed)).takeIf { it.results.isNotEmpty() }
+        } else {
+            null
+        }
+
+        return result ?: emptyPaginationResult()
+    }
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}
+
+fun <Key, Value> ReadKeyValuesRepo<Key, Value>.directlyCached(
+    kvCache: KeyValueRepo<Key, List<Value>>,
+    locker: SmartRWLocker = SmartRWLocker(),
+) = DirectFullReadKeyValuesCacheRepo(this, kvCache, locker)
+
+open class DirectFullWriteKeyValuesCacheRepo<Key,Value>(
+    parentRepo: WriteKeyValuesRepo<Key, Value>,
+    protected open val kvCache: KeyValueRepo<Key, List<Value>>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    protected val locker: SmartRWLocker = SmartRWLocker(),
+) : WriteKeyValuesRepo<Key, Value> by parentRepo, DirectFullCacheRepo {
+    protected val onNewJob = parentRepo.onNewValue.onEach {
+        locker.withWriteLock {
+            kvCache.set(
+                it.first,
+                kvCache.get(it.first) ?.plus(it.second) ?: listOf(it.second)
+            )
+        }
+    }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach {
+        locker.withWriteLock {
+            kvCache.set(
+                it.first,
+                kvCache.get(it.first)?.minus(it.second) ?: return@onEach
+            )
+        }
+    }.launchIn(scope)
+
+    override suspend fun invalidate() {
+        locker.withWriteLock {
+            kvCache.clear()
+        }
+    }
+}
+
+fun <Key, Value> WriteKeyValuesRepo<Key, Value>.directlyCached(
+    kvCache: KeyValueRepo<Key, List<Value>>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    locker: SmartRWLocker = SmartRWLocker(),
+) = DirectFullWriteKeyValuesCacheRepo(this, kvCache, scope, locker)
+
+open class DirectFullKeyValuesCacheRepo<Key,Value>(
+    override val parentRepo: KeyValuesRepo<Key, Value>,
+    kvCache: KeyValueRepo<Key, List<Value>>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker(writeIsLocked = !skipStartInvalidate),
+) : KeyValuesRepo<Key, Value>,
+    DirectFullReadKeyValuesCacheRepo<Key, Value>(parentRepo, kvCache, locker),
+    WriteKeyValuesRepo<Key, Value> by parentRepo {
+    init {
+        if (!skipStartInvalidate) {
+            scope.launchSafelyWithoutExceptions {
+                if (locker.writeMutex.isLocked) {
+                    initialInvalidate()
+                } else {
+                    invalidate()
+                }
+            }
+        }
+    }
+
+    override suspend fun clearWithValue(v: Value) {
+        doAllWithCurrentPaging {
+            keys(v, it).also {
+                remove(it.results.associateWith { listOf(v) })
+            }
+        }
+    }
+
+    protected open suspend fun initialInvalidate() {
+        try {
+            kvCache.actualizeAll(parentRepo, locker = null)
+        } finally {
+            locker.unlockWrite()
+        }
+    }
+    override suspend fun invalidate() {
+        kvCache.actualizeAll(parentRepo, locker = locker)
+    }
+
+    override suspend fun set(toSet: Map<Key, List<Value>>) {
+        locker.withWriteLock {
+            parentRepo.set(toSet)
+            kvCache.set(
+                toSet.filter {
+                    parentRepo.contains(it.key)
+                }
+            )
+        }
+    }
+
+    override suspend fun add(toAdd: Map<Key, List<Value>>) {
+        locker.withWriteLock {
+            parentRepo.add(toAdd)
+            toAdd.forEach {
+                val filtered = it.value.filter { v ->
+                    parentRepo.contains(it.key, v)
+                }.ifEmpty {
+                    return@forEach
+                }
+                kvCache.set(
+                    it.key,
+                    (kvCache.get(it.key) ?: emptyList()) + filtered
+                )
+            }
+        }
+    }
+
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
+        locker.withWriteLock {
+            parentRepo.remove(toRemove)
+            toRemove.forEach {
+                val filtered = it.value.filter { v ->
+                    !parentRepo.contains(it.key, v)
+                }.ifEmpty {
+                    return@forEach
+                }.toSet()
+                val resultList = (kvCache.get(it.key) ?: emptyList()) - filtered
+                if (resultList.isEmpty()) {
+                    kvCache.unset(it.key)
+                } else {
+                    kvCache.set(
+                        it.key,
+                        resultList
+                    )
+                }
+            }
+        }
+    }
+
+    override suspend fun clear(k: Key) {
+        locker.withWriteLock {
+            parentRepo.clear(k)
+            if (parentRepo.contains(k)) {
+                return@withWriteLock
+            }
+            kvCache.unset(k)
+        }
+    }
+}
+
+fun <Key, Value> KeyValuesRepo<Key, Value>.directlyFullyCached(
+    kvCache: KeyValueRepo<Key, List<Value>> = MapKeyValueRepo(),
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    skipStartInvalidate: Boolean = false,
+    locker: SmartRWLocker = SmartRWLocker(),
+) = DirectFullKeyValuesCacheRepo(this, kvCache, scope, skipStartInvalidate, locker)

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/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/value/KtorWriteKeyValueRepoClient.kt

@@ -8,7 +8,7 @@ import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
 import io.ktor.http.*
-import io.ktor.util.InternalAPI
+import io.ktor.utils.io.InternalAPI
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/values/KtorWriteKeyValuesRepoClient.kt

@@ -8,7 +8,7 @@ import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
 import io.ktor.http.*
-import io.ktor.util.InternalAPI
+import io.ktor.utils.io.InternalAPI
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow

repos/ktor/common/src/jvmTest/kotlin/KtorCRUDRepoTests.kt

@@ -25,7 +25,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class KtorCRUDRepoTests : CommonCRUDRepoTests() {
-    private var engine: ApplicationEngine? = null
+    private var engine: EmbeddedServer<*, *>? = null
 
     @BeforeTest
     fun beforeTest() {

repos/ktor/common/src/jvmTest/kotlin/KtorKeyValueRepoTests.kt

@@ -27,7 +27,7 @@ import kotlinx.serialization.json.Json
 import kotlin.test.*
 
 class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
-    private var engine: ApplicationEngine? = null
+    private var engine: EmbeddedServer<*, *>? = null
 
     override val repoCreator: suspend () -> KeyValueRepo<String, String> = {
         KtorKeyValueRepoClient(
@@ -77,7 +77,7 @@ class KtorKeyValueRepoTests : CommonKeyValueRepoTests() {
                         repo,
                         Int.serializer(),
                         ComplexData.serializer(),
-                        Json {}
+                        Json
                     )
                 }
             }.start(false)

repos/ktor/common/src/jvmTest/kotlin/KtorKeyValuesRepoTests.kt

@@ -23,7 +23,7 @@ import kotlinx.serialization.json.Json
 import kotlin.test.*
 
 class KtorKeyValuesRepoTests : CommonKeyValuesRepoTests() {
-    private var engine: ApplicationEngine? = null
+    private var engine: EmbeddedServer<*, *>? = null
     override val testSequencesSize: Int
         get() = 100
 

repos/ktor/common/src/jvmTest/kotlin/KtorRepoTestsHelper.kt

@@ -13,7 +13,7 @@ import io.ktor.server.websocket.*
 import kotlinx.serialization.json.Json
 
 object KtorRepoTestsHelper {
-    fun beforeTest(routingConfigurator: Routing.() -> Unit): ApplicationEngine {
+    fun beforeTest(routingConfigurator: Routing.() -> Unit): EmbeddedServer<CIOApplicationEngine, CIOApplicationEngine.Configuration> {
         return embeddedServer(
             CIO,
             23456,
@@ -28,7 +28,7 @@ object KtorRepoTestsHelper {
             routing(routingConfigurator)
         }.start(false)
     }
-    fun afterTest(engine: ApplicationEngine) {
+    fun afterTest(engine: EmbeddedServer<*, *>) {
         engine.stop()
     }
     fun client(): HttpClient = HttpClient {

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key/value/KtorReadKeyValueRepoRoutes.kt

@@ -16,7 +16,7 @@ import io.ktor.server.application.call
 import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.get
-import io.ktor.util.InternalAPI
+import io.ktor.utils.io.InternalAPI
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key/values/KtorReadKeyValuesRepoRoutes.kt

@@ -14,7 +14,7 @@ import io.ktor.server.application.call
 import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.get
-import io.ktor.util.InternalAPI
+import io.ktor.utils.io.InternalAPI
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 

serialization/typed_serializer/src/commonTest/kotlin/dev/inmo/micro_utils/serialization/typed_serializer/TypedSerializerTests.kt

@@ -11,7 +11,7 @@ class TypedSerializerTests {
     interface Example {
         val number: Number
     }
-    val serialFormat = Json {  }
+    val serialFormat = Json
 
     @Serializable
     data class Example1(override val number: Long) : Example