fixed

0.17.2

.github/workflows/build.yml

@@ -9,9 +9,6 @@ jobs:
       - uses: actions/setup-java@v1
         with:
           java-version: 11
-      - name: Fix android 32.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
@@ -20,9 +17,8 @@ jobs:
           mv gradle.properties.tmp gradle.properties
       - name: Build
         run: ./gradlew build
-#      - name: Publish
-#        continue-on-error: true
-#        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository
-#        env:
-#          GITHUBPACKAGES_USER: ${{ github.actor }}
-#          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}
+      - name: Publish
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGiteaRepository
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}

.github/workflows/dokka_push.yml

@@ -11,9 +11,6 @@ jobs:
       - uses: actions/setup-java@v1
         with:
           java-version: 11
-      - name: Fix android 32.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Build
         run: ./gradlew build && ./gradlew dokkaHtml
       - name: Publish KDocs

.space.kts

@@ -1,8 +0,0 @@
-job("Build and run tests") {
-    container(displayName = "Run gradle build", image = "openjdk:11") {
-        kotlinScript { api ->
-            // here can be your complex logic
-            api.gradlew("build")
-        }
-    }
-}

CHANGELOG.md

@@ -1,5 +1,212 @@
 # Changelog
 
+## 0.17.3
+
+* `Common`:
+    * Add `fixed` extensions for `Float` and `Double`
+    * New function `emptyDiff`
+    * Now you may pass custom `comparisonFun` to all `diff` functions
+
+## 0.17.2
+
+* `FSM`:
+    * `DefaultStatesManager.onUpdateContextsConflictResolver` and `DefaultStatesManager.onStartContextsConflictResolver` now return `false` by default
+
+## 0.17.1
+
+* **Hotfix** for absence of jvm dependencies in android modules
+* `Versions`:
+    * `Ktor`: `2.2.3` -> `2.2.4`
+
+## 0.17.0
+
+* `Versions`:
+    * `Kotlin`: `1.7.20` -> `1.8.10`
+    * `Serialization`: `1.4.1` -> `1.5.0`
+    * `KSLog`: `0.5.4` -> `1.0.0`
+    * `AppCompat`: `1.6.0` -> `1.6.1`
+
+## 0.16.13
+
+* `Repos`:
+    * `Generator`:
+        * Module has been created
+
+## 0.16.12
+
+* `Repos`:
+    * `Exposed`:
+        * `CommonExposedRepo.selectByIds` uses `foldRight` by default instead of raw foreach
+* `Koin`:
+    * `Generator`:
+        * Module has been created
+
+## 0.16.11
+
+* `LanguageCodes`:
+    * In android and JVM targets now available `toJavaLocale` and from Java `Locale` conversations from/to
+      `IetfLanguageCode`
+
+## 0.16.10
+
+* `Repos`:
+    * `Cache`:
+        * New transformer type: `ReadCRUDFromKeyValueRepo`
+        * New transformer type: `ReadKeyValueFromCRUDRepo`
+* `Pagination`:
+    * New `paginate` extensions with `reversed` support for `List`/`Set`
+
+## 0.16.9
+
+* `Versions`:
+    * `Koin`: `3.2.2` -> `3.3.2`
+    * `AppCompat`: `1.5.1` -> `1.6.0`
+* `Ktor`:
+    * `Client`
+        * `HttpResponse.bodyOrNull` now retrieve callback to check if body should be received or null
+        * New extension `HttpResponse.bodyOrNullOnNoContent`
+
+## 0.16.8
+
+* `Versions`:
+    * `Ktor`: `2.2.2` -> `2.2.3`
+* `Ktor`:
+    * `Client`
+        * Fixes in `HttpClient.uniUpload`
+    * `Server`
+        * Fixes in `PartData.FileItem.download`
+* `Repos`:
+    * `Cache`:
+        * New type of caches: `FallbackCacheRepo`
+        * Fixes in `Write*` variants of cached repos
+        * New type `ActionWrapper`
+        * New `AutoRecache*` classes for all types of repos as `FallbackCacheRepo`s
+    * `Common`:
+        * New transformations for key-value and key-values vice-verse
+        * Fixes in `FileReadKeyValueRepo`
+
+## 0.16.7
+
+* `Common`:
+    * New extensions `ifTrue`/`ifFalse`/`alsoIfTrue`/`alsoIfFalse`/`letIfTrue`/`letIfFalse`
+    * `Diff` now is serializable
+    * Add `IndexedValue` serializer
+    * `repeatOnFailure` extending: now you may pass any lambda to check if continue to try/do something
+    * `Compose`:
+        * New extension `MutableState.asState`
+* `Coroutines`:
+    * `Compose`:
+        * All the `Flow` conversations to compose `State`/`MutableState`/`SnapshotStateList`/`List` got several new
+        parameters
+        * `Flow.toMutableState` now is deprecated in favor to `asMutableComposeState`
+* `Repos`:
+    * `Cache`:
+        * New type `FullCacheRepo`
+        * New type `CommonCacheRepo`
+        * `CacheRepo` got `invalidate` method. It will fully reload `FullCacheRepo` and just clear `CommonCacheRepo`
+        * New extensions `KVCache.actualizeAll`
+
+## 0.16.6
+
+* `Startup`:
+    * `Launcher`:
+        * Improvements in `StartLauncherPlugin#start` methods
+        * Add opportunity to pass second argument on `JVM` platform as log level
+* `Repos`:
+    * `Ktor`:
+        * `Client`:
+            * All clients repos got opportunity to customize their flows
+    * `Exposed`:
+        * Extensions `eqOrIsNull` and `neqOrIsNotNull` for `Column`
+
+## 0.16.5
+
+* `Versions`:
+    * `Ktor`: `2.2.1` -> `2.2.2`
+
+## 0.16.4
+
+* `Coroutines`:
+    * Create `launchInCurrentThread`
+
+## 0.16.3
+
+* `Startup`:
+    * `Launcher`:
+        * All starting API have been moved into `StartLauncherPlugin` and do not require serialize/deserialize cycle for now
+
+## 0.16.2
+
+* `Versions`:
+    * `Compose`: `1.2.1` -> `1.2.2`
+* `Startup`:
+    * Module become available on `JS` target
+
+## 0.16.1
+
+* `Coroutines`:
+    * New `runCatchingSafely`/`safelyWithResult` with receivers
+* `SafeWrapper`:
+    * Module inited
+
+## 0.16.0
+
+* `Versions`:
+    * `Ktor`: `2.1.3` -> `2.2.1`
+    * `Android Fragment`: `1.5.3` -> `1.5.5`
+
+## 0.15.1
+
+* `Startup`:
+    * Inited :)
+    * `Plugin`:
+        * Inited :)
+    * `Launcher`:
+        * Inited :)
+
+## 0.15.0
+
+* `Repos`:
+    * `CRUD`:
+        * `Common`:
+            * New method `ReadCRUDRepo#getIdsByPagination`
+        * `Android`:
+            * `AbstractAndroidCRUDRepo` got new abstract method `toId`
+        * `Exposed`:
+            * `CommonExposedRepo` new abstract property `asId`
+        * `Ktor`:
+            * `Client`:
+                * `KtorReadCRUDRepoClient` now requires `paginationIdType`
+* `LanguageCodes`:
+    * Updates and fixes in generation
+* `MimeTypes`:
+    * Updates and fixes in generation
+
+## 0.14.4
+
+* `Common`:
+    * `JVM`:
+        * New extension `downloadToTempFile`
+* `Ktor`:
+    * `Server`:
+        * Small fix in `handleUniUpload`
+        * `ApplicationCall#uniloadMultipartFile` now uses `uniloadMultipart`
+    * `Common`:
+        * New extension `downloadToTempFile`
+    * `Client`:
+        * New extensions on top of `uniUpload`
+
+## 0.14.3
+
+* `Common`:
+    * New type `Progress`
+* `Ktor`:
+    * `Client`:
+        * New universal `uniUpload` extension for `HttpClient`
+    * `Server`:
+        * New universal `handleUniUpload` extension for `ApplicationCall`
+        * Add extensions `download` and `downloadToTemporalFile`
+
 ## 0.14.2
 
 * `Versions`:

build.gradle

@@ -9,6 +9,7 @@ buildscript {
     dependencies {
         classpath libs.buildscript.kt.gradle
         classpath libs.buildscript.kt.serialization
+        classpath libs.buildscript.kt.ksp
         classpath libs.buildscript.jb.dokka
         classpath libs.buildscript.gh.release
         classpath libs.buildscript.android.gradle

common/build.gradle

@@ -18,6 +18,7 @@ kotlin {
                 api project(":micro_utils.coroutines")
                 api libs.android.fragment
             }
+            dependsOn jvmMain
         }
     }
 }

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

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.common.compose
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.State
+import androidx.compose.runtime.derivedStateOf
+
+/**
+ * Converts current [MutableState] to immutable [State] using [derivedStateOf]
+ */
+fun <T> MutableState<T>.asState(): State<T> = derivedStateOf { this.value }

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

@@ -2,6 +2,8 @@
 
 package dev.inmo.micro_utils.common
 
+import kotlinx.serialization.Serializable
+
 private inline fun <T> getObject(
     additional: MutableList<T>,
     iterator: Iterator<T>
@@ -24,14 +26,19 @@ private inline fun <T> getObject(
  *
  * @see calculateDiff
  */
+@Serializable
 data class Diff<T> internal constructor(
-    val removed: List<IndexedValue<T>>,
+    val removed: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>,
     /**
      * Old-New values pairs
      */
-    val replaced: List<Pair<IndexedValue<T>, IndexedValue<T>>>,
-    val added: List<IndexedValue<T>>
-)
+    val replaced: List<Pair<@Serializable(IndexedValueSerializer::class) IndexedValue<T>, @Serializable(IndexedValueSerializer::class) IndexedValue<T>>>,
+    val added: List<@Serializable(IndexedValueSerializer::class) IndexedValue<T>>
+) {
+    fun isEmpty(): Boolean = removed.isEmpty() && replaced.isEmpty() && added.isEmpty()
+}
+
+fun <T> emptyDiff(): Diff<T> = Diff(emptyList(), emptyList(), emptyList())
 
 private inline fun <T> performChanges(
     potentialChanges: MutableList<Pair<IndexedValue<T>?, IndexedValue<T>?>>,
@@ -40,14 +47,14 @@ private inline fun <T> performChanges(
     changedList: MutableList<Pair<IndexedValue<T>, IndexedValue<T>>>,
     removedList: MutableList<IndexedValue<T>>,
     addedList: MutableList<IndexedValue<T>>,
-    strictComparison: Boolean
+    comparisonFun: (T?, T?) -> Boolean
 ) {
     var i = -1
     val (oldObject, newObject) = potentialChanges.lastOrNull() ?: return
     for ((old, new) in potentialChanges.take(potentialChanges.size - 1)) {
         i++
-        val oldOneEqualToNewObject = old ?.value === newObject ?.value || (old ?.value == newObject ?.value && !strictComparison)
-        val newOneEqualToOldObject = new ?.value === oldObject ?.value || (new ?.value == oldObject ?.value && !strictComparison)
+        val oldOneEqualToNewObject = comparisonFun(old ?.value, newObject ?.value)
+        val newOneEqualToOldObject = comparisonFun(new ?.value, oldObject ?.value)
         if (oldOneEqualToNewObject || newOneEqualToOldObject) {
             changedList.addAll(
                 potentialChanges.take(i).mapNotNull {
@@ -101,7 +108,7 @@ private inline fun <T> performChanges(
  */
 fun <T> Iterable<T>.calculateDiff(
     other: Iterable<T>,
-    strictComparison: Boolean = false
+    comparisonFun: (T?, T?) -> Boolean
 ): Diff<T> {
     var i = -1
     var j = -1
@@ -129,7 +136,7 @@ fun <T> Iterable<T>.calculateDiff(
         }
 
         when {
-            oldObject === newObject || (oldObject == newObject && !strictComparison) -> {
+            comparisonFun(oldObject, newObject) -> {
                 changedObjects.addAll(potentiallyChangedObjects.map {
                     @Suppress("UNCHECKED_CAST")
                     it as Pair<IndexedValue<T>, IndexedValue<T>>
@@ -140,23 +147,49 @@ fun <T> Iterable<T>.calculateDiff(
                 potentiallyChangedObjects.add(oldObject ?.let { IndexedValue(i, oldObject) } to newObject ?.let { IndexedValue(j, newObject) })
                 val previousOldsAdditionsSize = additionalInOld.size
                 val previousNewsAdditionsSize = additionalInNew.size
-                performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, strictComparison)
+                performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, comparisonFun)
                 i -= (additionalInOld.size - previousOldsAdditionsSize)
                 j -= (additionalInNew.size - previousNewsAdditionsSize)
             }
         }
     }
     potentiallyChangedObjects.add(null to null)
-    performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, strictComparison)
+    performChanges(potentiallyChangedObjects, additionalInOld, additionalInNew, changedObjects, removedObjects, addedObjects, comparisonFun)
 
     return Diff(removedObjects.toList(), changedObjects.toList(), addedObjects.toList())
 }
+
+/**
+ * Calculating [Diff] object
+ *
+ * @param strictComparison If this parameter set to true, objects which are not equal by links will be used as different
+ * objects. For example, in case of two "Example" string they will be equal by value, but CAN be different by links
+ */
+fun <T> Iterable<T>.calculateDiff(
+    other: Iterable<T>,
+    strictComparison: Boolean = false
+): Diff<T> = calculateDiff(
+    other,
+    comparisonFun = if (strictComparison) {
+        { t1, t2 ->
+            t1 === t2
+        }
+    } else {
+        { t1, t2 ->
+            t1 === t2 || t1 == t2 // small optimization for cases when t1 and t2 are the same - comparison will be faster potentially
+        }
+    }
+)
 inline fun <T> Iterable<T>.diff(
     other: Iterable<T>,
     strictComparison: Boolean = false
 ): Diff<T> = calculateDiff(other, strictComparison)
+inline fun <T> Iterable<T>.diff(
+    other: Iterable<T>,
+    noinline comparisonFun: (T?, T?) -> Boolean
+): Diff<T> = calculateDiff(other, comparisonFun)
 
-inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new)
+inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, strictComparison = false)
 inline fun <T> StrictDiff(old: Iterable<T>, new: Iterable<T>) = old.calculateDiff(new, true)
 
 /**
@@ -184,3 +217,22 @@ fun <T> MutableList<T>.applyDiff(
         set(new.index, new.value)
     }
 }
+
+/**
+ * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
+ * mutable list
+ */
+fun <T> MutableList<T>.applyDiff(
+    source: Iterable<T>,
+    comparisonFun: (T?, T?) -> Boolean
+): Diff<T> = calculateDiff(source, comparisonFun).also {
+    for (i in it.removed.indices.sortedDescending()) {
+        removeAt(it.removed[i].index)
+    }
+    it.added.forEach { (i, t) ->
+        add(i, t)
+    }
+    it.replaced.forEach { (_, new) ->
+        set(new.index, new.value)
+    }
+}

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

@@ -0,0 +1,43 @@
+package dev.inmo.micro_utils.common
+
+inline fun <T> Boolean.letIfTrue(block: () -> T): T? {
+    return if (this) {
+        block()
+    } else {
+        null
+    }
+}
+
+inline fun <T> Boolean.letIfFalse(block: () -> T): T? {
+    return if (this) {
+        null
+    } else {
+        block()
+    }
+}
+
+inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean {
+    letIfTrue(block)
+    return this
+}
+
+inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean {
+    letIfFalse(block)
+    return this
+}
+
+inline fun <T> Boolean.ifTrue(block: () -> T): T? {
+    return if (this) {
+        block()
+    } else {
+        null
+    }
+}
+
+inline fun <T> Boolean.ifFalse(block: () -> T): T? {
+    return if (this) {
+        null
+    } else {
+        block()
+    }
+}

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

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.common
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.PairSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+class IndexedValueSerializer<T>(private val subSerializer: KSerializer<T>) : KSerializer<IndexedValue<T>> {
+    private val originalSerializer = PairSerializer(Int.serializer(), subSerializer)
+    override val descriptor: SerialDescriptor
+        get() = originalSerializer.descriptor
+
+    override fun deserialize(decoder: Decoder): IndexedValue<T> {
+        val pair = originalSerializer.deserialize(decoder)
+        return IndexedValue(
+            pair.first,
+            pair.second
+        )
+    }
+
+    override fun serialize(encoder: Encoder, value: IndexedValue<T>) {
+        originalSerializer.serialize(
+            encoder,
+            Pair(value.index, value.value)
+        )
+    }
+}

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

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

@@ -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 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/RepeatOnFailure.kt

@@ -1,5 +1,27 @@
 package dev.inmo.micro_utils.common
 
+/**
+ * Executes the given [action] until getting of successful result specified number of [times].
+ *
+ * A zero-based index of current iteration is passed as a parameter to [action].
+ */
+inline fun <R> repeatOnFailure(
+    onFailure: (Throwable) -> Boolean,
+    action: () -> R
+): Result<R> {
+    do {
+        runCatching {
+            action()
+        }.onFailure {
+            if (!onFailure(it)) {
+                return Result.failure(it)
+            }
+        }.onSuccess {
+            return Result.success(it)
+        }
+    } while (true)
+}
+
 /**
  * Executes the given [action] until getting of successful result specified number of [times].
  *
@@ -10,12 +32,23 @@ inline fun <R> repeatOnFailure(
     onEachFailure: (Throwable) -> Unit = {},
     action: (Int) -> R
 ): Optional<R> {
-    repeat(times) {
-        runCatching {
-            action(it)
-        }.onFailure(onEachFailure).onSuccess {
-            return Optional.presented(it)
+    var i = 0
+    val result = repeatOnFailure(
+        {
+            onEachFailure(it)
+            if (i < times) {
+                i++
+                true
+            } else {
+                false
+            }
         }
+    ) {
+        action(i)
+    }
+    return if (result.isSuccess) {
+        Optional.presented(result.getOrThrow())
+    } else {
+        Optional.absent()
     }
-    return Optional.absent()
 }

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.common
+
+val FixedSignsRange = 0 .. 100
+
+expect fun Float.fixed(signs: Int): Float
+expect fun Double.fixed(signs: Int): Double

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

@@ -0,0 +1,4 @@
+package dev.inmo.micro_utils.common
+
+actual fun Float.fixed(signs: Int): Float = this.asDynamic().toFixed(signs.coerceIn(FixedSignsRange)).unsafeCast<String>().toFloat()
+actual fun Double.fixed(signs: Int): Double = this.asDynamic().toFixed(signs.coerceIn(FixedSignsRange)).unsafeCast<String>().toDouble()

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

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.common
+
+import java.io.File
+import java.io.InputStream
+import java.util.UUID
+
+fun InputStream.downloadToTempFile(
+    fileName: String = UUID.randomUUID().toString(),
+    fileExtension: String? = ".temp",
+    folder: File? = null
+) = File.createTempFile(
+    fileName,
+    fileExtension,
+    folder
+).apply {
+    outputStream().use {
+        copyTo(it)
+    }
+    deleteOnExit()
+}

common/src/jvmMain/kotlin/dev/inmo/micro_utils/common/ToFixedActual.kt

@@ -0,0 +1,12 @@
+package dev.inmo.micro_utils.common
+
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+actual fun Float.fixed(signs: Int): Float = BigDecimal.valueOf(this.toDouble())
+    .setScale(signs.coerceIn(FixedSignsRange), RoundingMode.HALF_UP)
+    .toFloat();
+
+actual fun Double.fixed(signs: Int): Double = BigDecimal.valueOf(this)
+    .setScale(signs.coerceIn(FixedSignsRange), RoundingMode.HALF_UP)
+    .toDouble();

coroutines/build.gradle

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

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

@@ -3,24 +3,58 @@ package dev.inmo.micro_utils.coroutines.compose
 import androidx.compose.runtime.*
 import androidx.compose.runtime.snapshots.SnapshotStateList
 import dev.inmo.micro_utils.common.applyDiff
+import dev.inmo.micro_utils.coroutines.ExceptionHandler
+import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.CoroutineContext
 
+/**
+ * Each value of [this] [Flow] will trigger [applyDiff] to the result [SnapshotStateList]
+ *
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [SnapshotStateList]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <reified T> Flow<List<T>>.asMutableComposeListState(
-    scope: CoroutineScope
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
 ): SnapshotStateList<T> {
     val state = mutableStateListOf<T>()
-    subscribeSafelyWithoutExceptions(scope) {
+    val changeBlock: suspend (List<T>) -> Unit = useContextOnChange ?.let {
+        {
+            withContext(useContextOnChange) {
+                state.applyDiff(it)
+            }
+        }
+    } ?: {
         state.applyDiff(it)
     }
+    subscribeSafelyWithoutExceptions(scope, onException, changeBlock)
     return state
 }
 
+/**
+ * In fact, it is just classcast of [asMutableComposeListState] to [List]
+ *
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [List]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ *
+ * @return Changing in time [List] which follow [Flow] values
+ */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <reified T> Flow<List<T>>.asComposeList(
-    scope: CoroutineScope
-): List<T> = asMutableComposeListState(scope)
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    noinline onException: ExceptionHandler<List<T>?> = defaultSafelyWithoutExceptionHandlerWithNull,
+): List<T> = asMutableComposeListState(scope, useContextOnChange, onException)
 

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

@@ -1,35 +1,94 @@
 package dev.inmo.micro_utils.coroutines.compose
 
 import androidx.compose.runtime.*
+import dev.inmo.micro_utils.common.compose.asState
+import dev.inmo.micro_utils.coroutines.ExceptionHandler
+import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandlerWithNull
+import dev.inmo.micro_utils.coroutines.doInUI
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.CoroutineContext
 
+/**
+ * Will map [this] [Flow] as [MutableState]. Returned [MutableState] WILL NOT change source [Flow]
+ *
+ * @param initial First value which will be passed to the result [MutableState]
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ */
 fun <T> Flow<T>.asMutableComposeState(
     initial: T,
-    scope: CoroutineScope
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
 ): MutableState<T> {
     val state = mutableStateOf(initial)
-    subscribeSafelyWithoutExceptions(scope) { state.value = it }
+    val changeBlock: suspend (T) -> Unit = useContextOnChange ?.let {
+        {
+            withContext(useContextOnChange) {
+                state.value = it
+            }
+        }
+    } ?: {
+        state.value = it
+    }
+    subscribeSafelyWithoutExceptions(scope, onException, block = changeBlock)
     return state
 }
 
+/**
+ * Will map [this] [StateFlow] as [MutableState]. Returned [MutableState] WILL NOT change source [StateFlow].
+ * This conversation will pass its [StateFlow.value] as the first value
+ *
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [MutableState]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> StateFlow<T>.asMutableComposeState(
-    scope: CoroutineScope
-): MutableState<T> = asMutableComposeState(value, scope)
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+): MutableState<T> = asMutableComposeState(value, scope, useContextOnChange, onException)
 
+/**
+ * Will create [MutableState] using [asMutableComposeState] and use [asState] to convert it as immutable state
+ *
+ * @param initial First value which will be passed to the result [State]
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ */
 fun <T> Flow<T>.asComposeState(
     initial: T,
-    scope: CoroutineScope
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
 ): State<T> {
-    val state = asMutableComposeState(initial, scope)
-    return derivedStateOf { state.value }
+    val state = asMutableComposeState(initial, scope, useContextOnChange, onException)
+    return state.asState()
 }
 
+/**
+ * Will map [this] [StateFlow] as [State]. This conversation will pass its [StateFlow.value] as the first value
+ *
+ * @param scope Will be used to [subscribeSafelyWithoutExceptions] on [this] to update returned [State]
+ * @param useContextOnChange Will be used to change context inside of [subscribeSafelyWithoutExceptions] to ensure that
+ * change will happen in the required [CoroutineContext]. [Dispatchers.Main] by default
+ * @param onException Will be passed to the [subscribeSafelyWithoutExceptions] as uncaught exceptions handler
+ */
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> StateFlow<T>.asComposeState(
-    scope: CoroutineScope
-): State<T> = asComposeState(value, scope)
+    scope: CoroutineScope,
+    useContextOnChange: CoroutineContext? = Dispatchers.Main,
+    noinline onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
+): State<T> = asComposeState(value, scope, useContextOnChange, onException)
 

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

@@ -7,17 +7,15 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
 
+@Deprecated("Duplicated functionality", ReplaceWith("asMutableComposeState(initial, scope)", "dev.inmo.micro_utils.coroutines.compose.asMutableComposeState"))
 fun <T> Flow<T>.toMutableState(
     initial: T,
     scope: CoroutineScope
-): MutableState<T> {
-    val state = mutableStateOf(initial)
-    subscribeSafelyWithoutExceptions(scope) { state.value = it }
-    return state
-}
+): MutableState<T> = asMutableComposeState(initial, scope)
 
+@Deprecated("Duplicated functionality", ReplaceWith("asMutableComposeState(scope)", "dev.inmo.micro_utils.coroutines.compose.asMutableComposeState"))
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T> StateFlow<T>.toMutableState(
     scope: CoroutineScope
-): MutableState<T> = toMutableState(value, scope)
+): MutableState<T> = asMutableComposeState(scope)
 

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

@@ -115,10 +115,21 @@ suspend inline fun <T> runCatchingSafely(
     safely(onException, block)
 }
 
+suspend inline fun <T, R> T.runCatchingSafely(
+    noinline onException: ExceptionHandler<R> = defaultSafelyExceptionHandler,
+    noinline block: suspend T.() -> R
+): Result<R> = runCatching {
+    safely(onException) { block() }
+}
+
 suspend inline fun <T> safelyWithResult(
     noinline block: suspend CoroutineScope.() -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
 
+suspend inline fun <T, R> T.safelyWithResult(
+    noinline block: suspend T.() -> R
+): Result<R> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
  * returning null at one time

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

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+
+fun <T> launchInCurrentThread(block: suspend CoroutineScope.() -> T): T {
+    val scope = CoroutineScope(Dispatchers.Unconfined)
+    return scope.launchSynchronously(block)
+}

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

@@ -6,7 +6,7 @@ fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T
     var result: Result<T>? = null
     val objectToSynchronize = Object()
     synchronized(objectToSynchronize) {
-        launch {
+        launch(start = CoroutineStart.UNDISPATCHED) {
             result = safelyWithResult(block)
         }.invokeOnCompletion {
             synchronized(objectToSynchronize) {

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

@@ -0,0 +1,47 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LaunchInCurrentThreadTests {
+    @Test
+    fun simpleTestThatLaunchInCurrentThreadWorks() {
+        val expectedResult = 10
+        val result = launchInCurrentThread {
+            expectedResult
+        }
+        assertEquals(expectedResult, result)
+    }
+    @Test
+    fun simpleTestThatSeveralLaunchInCurrentThreadWorks() {
+        val testData = 0 until 100
+
+        testData.forEach {
+            val result = launchInCurrentThread {
+                it
+            }
+            assertEquals(it, result)
+        }
+    }
+    @Test
+    fun simpleTestThatLaunchInCurrentThreadWillCorrectlyHandleSuspensionsWorks() {
+        val testData = 0 until 100
+
+        suspend fun test(data: Any): Any {
+            return withContext(Dispatchers.Default) {
+                delay(1)
+                data
+            }
+        }
+
+        testData.forEach {
+            val result = launchInCurrentThread {
+                test(it)
+            }
+            assertEquals(it, result)
+        }
+    }
+}

defaultAndroidSettings.gradle

@@ -1,30 +1,5 @@
 apply plugin: 'com.getkeepsafe.dexcount'
 
-ext {
-    jvmKotlinFolderFile = {
-        String sep = File.separator
-        return new File("${project.projectDir}${sep}src${sep}jvmMain${sep}kotlin")
-    }
-
-    enableIncludingJvmCodeInAndroidPart = {
-        File jvmKotlinFolder = jvmKotlinFolderFile()
-        if (jvmKotlinFolder.exists()) {
-            android.sourceSets.main.java.srcDirs += jvmKotlinFolder.path
-        }
-    }
-
-    disableIncludingJvmCodeInAndroidPart = {
-        File jvmKotlinFolder = jvmKotlinFolderFile()
-        String[] oldDirs = android.sourceSets.main.java.srcDirs
-        android.sourceSets.main.java.srcDirs = []
-        for (oldDir in oldDirs) {
-            if (oldDir != jvmKotlinFolder.path) {
-                android.sourceSets.main.java.srcDirs += oldDir
-            }
-        }
-    }
-}
-
 android {
     compileSdkVersion libs.versions.android.props.compileSdk.get().toInteger()
     buildToolsVersion libs.versions.android.props.buildTools.get()
@@ -58,10 +33,4 @@ android {
     kotlinOptions {
         jvmTarget = JavaVersion.VERSION_1_8.toString()
     }
-
-    sourceSets {
-        String sep = File.separator
-        main.java.srcDirs += "src${sep}main${sep}kotlin"
-        enableIncludingJvmCodeInAndroidPart()
-    }
 }

dokka/build.gradle

@@ -121,11 +121,11 @@ tasks.dokkaHtml {
 //        }
 
         named("jvmMain") {
-            sourceRoots.setFrom(findSourcesWithName("jvmMain", "commonMain"))
+            sourceRoots.setFrom(findSourcesWithName("jvmMain"))
         }
 
         named("androidMain") {
-            sourceRoots.setFrom(findSourcesWithName("androidMain", "commonMain"))
+            sourceRoots.setFrom(findSourcesWithName("androidMain"))
         }
     }
 }

extensions.gradle

@@ -23,11 +23,12 @@ allprojects {
         mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
         mppProjectWithSerializationAndComposePresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerializationAndCompose.gradle"
         mppJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJavaProject.gradle"
+        mppJsAndJavaProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJsAndJavaProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"
 
         publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
-        publishMavenPath = "${rootProject.projectDir.absolutePath}/maven.publish.gradle"
+        publishJvmOnlyPath = "${rootProject.projectDir.absolutePath}/jvm.publish.gradle"
     }
 }

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

@@ -48,8 +48,8 @@ interface DefaultStatesManagerRepo<T : State> {
  */
 open class DefaultStatesManager<T : State>(
     protected val repo: DefaultStatesManagerRepo<T> = InMemoryDefaultStatesManagerRepo(),
-    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> true },
-    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> true }
+    protected val onStartContextsConflictResolver: suspend (current: T, new: T) -> Boolean = { _, _ -> false },
+    protected val onUpdateContextsConflictResolver: suspend (old: T, new: T, currentNew: T) -> Boolean = { _, _, _ -> false }
 ) : StatesManager<T> {
     protected val _onChainStateUpdated = MutableSharedFlow<Pair<T, T>>(0)
     override val onChainStateUpdated: Flow<Pair<T, T>> = _onChainStateUpdated.asSharedFlow()

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.14.2
-android_code_version=163
+version=0.17.3
+android_code_version=185

gradle/libs.versions.toml

@@ -1,35 +1,40 @@
 [versions]
 
-kt = "1.7.20"
-kt-serialization = "1.4.1"
+kt = "1.8.10"
+kt-serialization = "1.5.0"
 kt-coroutines = "1.6.4"
 
-jb-compose = "1.2.1"
+kslog = "1.0.0"
+
+jb-compose = "1.3.1-rc01"
 jb-exposed = "0.41.1"
 jb-dokka = "1.7.20"
 
 klock = "3.4.0"
-uuid = "0.6.0"
+uuid = "0.7.0"
 
-ktor = "2.1.3"
+ktor = "2.2.4"
 
 gh-release = "2.4.1"
 
-koin = "3.2.2"
+koin = "3.3.2"
 
-android-gradle = "7.2.2"
-dexcount = "3.1.0"
+ksp = "1.8.10-1.0.9"
+kotlin-poet = "1.12.0"
+
+android-gradle = "7.3.1"
+dexcount = "4.0.0"
 
 android-coreKtx = "1.9.0"
 android-recyclerView = "1.2.1"
-android-appCompat = "1.5.1"
-android-fragment = "1.5.3"
-android-espresso = "3.4.0"
-android-test = "1.1.3"
+android-appCompat = "1.6.1"
+android-fragment = "1.5.5"
+android-espresso = "3.5.1"
+android-test = "1.1.5"
 
 android-props-minSdk = "21"
 android-props-compileSdk = "33"
-android-props-buildTools = "33.0.0"
+android-props-buildTools = "33.0.1"
 
 [libraries]
 
@@ -60,6 +65,7 @@ ktor-server-websockets = { module = "io.ktor:ktor-server-websockets", version.re
 ktor-server-statusPages = { module = "io.ktor:ktor-server-status-pages", version.ref = "ktor" }
 ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negotiation", version.ref = "ktor" }
 
+kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
 
 klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "klock" }
 uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
@@ -80,9 +86,16 @@ android-test-junit = { module = "androidx.test.ext:junit", version.ref = "androi
 kt-test-js = { module = "org.jetbrains.kotlin:kotlin-test-js", version.ref = "kt" }
 kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kt" }
 
+# ksp dependencies
+
+kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
+ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
+
+# Buildscript
 
 buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }
 buildscript-kt-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kt" }
+buildscript-kt-ksp = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
 buildscript-jb-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "jb-dokka" }
 buildscript-gh-release = { module = "com.github.breadmoirai:github-release", version.ref = "gh-release" }
 buildscript-android-gradle = { module = "com.android.tools.build:gradle", version.ref = "android-gradle" }

gradle/wrapper/gradle-wrapper.properties

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

jvm.publish.gradle

@@ -0,0 +1,118 @@
+apply plugin: 'maven-publish'
+
+task javadocJar(type: Jar) {
+    from javadoc
+    classifier = 'javadoc'
+}
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+
+            artifact javadocJar
+            artifact sourcesJar
+
+            pom {
+                resolveStrategy = Closure.DELEGATE_FIRST
+
+                description = "It is set of projects with micro tools for avoiding of routines coding"
+                name = "${project.name}"
+                url = "https://github.com/InsanusMokrassar/MicroUtils/"
+
+                scm {
+                    developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/MicroUtils.git[push=]https://github.com/InsanusMokrassar/MicroUtils.git"
+                    url = "https://github.com/InsanusMokrassar/MicroUtils.git"
+                }
+
+                developers {
+                    
+                        developer {
+                            id = "InsanusMokrassar"
+                            name = "Aleksei Ovsiannikov"
+                            email = "ovsyannikov.alexey95@gmail.com"
+                        }
+                    
+
+                        developer {
+                            id = "000Sanya"
+                            name = "Syrov Aleksandr"
+                            email = "000sanya.000sanya@gmail.com"
+                        }
+                    
+                }
+
+                licenses {
+                    
+                        license {
+                            name = "Apache Software License 2.0"
+                            url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
+                        }
+                    
+                }
+            }
+            repositories {
+                if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
+                    maven {
+                        name = "GithubPackages"
+                        url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+                
+                        credentials {
+                            username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
+                            password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
+                        }
+                
+                    }
+                }
+                if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                    maven {
+                        name = "Gitea"
+                        url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+                
+                        credentials(HttpHeaderCredentials) {
+                            name = "Authorization"
+                            value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                        }
+                
+                        authentication {
+                            header(HttpHeaderAuthentication)
+                        }
+                
+                    }
+                }
+                if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                    maven {
+                        name = "sonatype"
+                        url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+                
+                        credentials {
+                            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                        }
+                
+                    }
+                }
+            }
+        }
+    }
+}
+
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
+}

jvm.publish.kpsb

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

koin/generator/README.md

@@ -0,0 +1,100 @@
+# Koin generator
+
+It is Kotlin Symbol Processing generator for `Koin` module in `MicroUtils`.
+
+1. [What may do this generator](#what-may-do-this-generator)
+2. [How to add generator](#how-to-add-generator)
+
+## What may do this generator
+
+Let's imagine you want to have shortcuts in koin, to get something easily:
+
+```kotlin
+val koin: Koin// some initialization
+
+val someUrl = koin.serverUrl
+```
+
+So, in that case you may mark containing file with next annotation (in the beginning of file):
+
+```kotlin
+@file:GenerateKoinDefinition("serverUrl", String::class, nullable = false)
+```
+
+If file is called like `Sample.kt`, will be generated file `GeneratedDefinitionsSample.kt` with next content:
+
+```kotlin
+public val Scope.serverUrl: String
+  get() = get(named("serverUrl"))
+
+public val Koin.serverUrl: String
+  get() = get(named("serverUrl"))
+
+public fun Module.serverUrlSingle(createdAtStart: Boolean = false,
+    definition: Definition<String>): KoinDefinition<String> =
+    single(named("serverUrl"), createdAtStart = createdAtStart, definition = definition)
+
+public fun Module.serverUrlFactory(definition: Definition<String>):
+    KoinDefinition<String> = factory(named("serverUrl"), definition = definition)
+```
+
+Besides, you may use the generics:
+
+```kotlin
+@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false)
+```
+
+Will generate:
+
+```kotlin
+public val Scope.sampleInfo: Sample<G1, G2>
+  get() = get(named("sampleInfo"))
+
+public val Koin.sampleInfo: Sample<G1, G2>
+  get() = get(named("sampleInfo"))
+
+public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
+    definition: Definition<Sample<G1, G2>>): KoinDefinition<Sample<G1, G2>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+
+public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
+    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
+```
+
+In case you wish not to generate single:
+
+```kotlin
+@file:GenerateKoinDefinition("sampleInfo", Sample::class, G1::class, G2::class, nullable = false, generateSingle = false)
+```
+
+And you will take next code:
+
+```kotlin
+public val Scope.sampleInfo: Sample<G1, G2>
+  get() = get(named("sampleInfo"))
+
+public val Koin.sampleInfo: Sample<G1, G2>
+  get() = get(named("sampleInfo"))
+
+public fun Module.sampleInfoFactory(definition: Definition<Sample<G1, G2>>):
+    KoinDefinition<Sample<G1, G2>> = factory(named("sampleInfo"), definition = definition)
+```
+
+## How to add generator
+
+**Note: $ksp_version in the samples above is equal to supported `ksp` version presented in `/gradle/libs.versions.toml` of project**
+
+**Note: $microutils_version in the version of MicroUtils library in your project**
+
+1. Add `classpath` in `build.gradle` (`classpath "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"`)
+2. Add plugin to the plugins list of your module: `id "com.google.devtools.ksp"`
+3. In `dependencies` block add to the required target/compile the dependency `dev.inmo:micro_utils.koin.generator:$microutils_version`:
+   ```groovy
+    dependencies {
+        add("kspCommonMainMetadata", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in commonMain of your multiplatform module
+        add("kspJvm", "dev.inmo:micro_utils.koin.generator:$microutils_version") // will work in main of your JVM module
+    }
+    
+    ksp { // this generator do not require any arguments and we should left `ksp` empty
+    }
+    ```

koin/generator/build.gradle

@@ -0,0 +1,15 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+}
+
+apply from: "$publishJvmOnlyPath"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api project(":micro_utils.koin")
+    api libs.kotlin.poet
+    api libs.ksp
+}

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

@@ -0,0 +1,178 @@
+package dev.inmo.micro_utils.koin.generator
+
+import com.google.devtools.ksp.KSTypeNotPresentException
+import com.google.devtools.ksp.KSTypesNotPresentException
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getAnnotationsByType
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSFile
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.asTypeName
+import com.squareup.kotlinpoet.ksp.toClassName
+import com.squareup.kotlinpoet.ksp.toTypeName
+import com.squareup.kotlinpoet.ksp.writeTo
+import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.scope.Scope
+import java.io.File
+import kotlin.reflect.KClass
+
+class Processor(
+    private val codeGenerator: CodeGenerator
+) : SymbolProcessor {
+    private val definitionClassName = ClassName("org.koin.core.definition", "Definition")
+    private val koinDefinitionClassName = ClassName("org.koin.core.definition", "KoinDefinition")
+
+    @OptIn(KspExperimental::class)
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        resolver.getSymbolsWithAnnotation(
+            GenerateKoinDefinition::class.qualifiedName!!
+        ).filterIsInstance<KSFile>().forEach { ksFile ->
+            FileSpec.builder(
+                ksFile.packageName.asString(),
+                "GeneratedDefinitions${ksFile.fileName.removeSuffix(".kt")}"
+            ).apply {
+                addFileComment(
+                    """
+                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+                        TO REGENERATE IT JUST DELETE FILE
+                        ORIGINAL FILE: ${ksFile.fileName}
+                    """.trimIndent()
+                )
+                ksFile.getAnnotationsByType(GenerateKoinDefinition::class).forEach {
+                    val type = runCatching {
+                        it.type.asTypeName()
+                    }.getOrElse { e ->
+                        if (e is KSTypeNotPresentException) {
+                            e.ksType.toClassName()
+                        } else {
+                            throw e
+                        }
+                    }
+                    val targetType = runCatching {
+                        type.parameterizedBy(*(it.typeArgs.takeIf { it.isNotEmpty() } ?.map { it.asTypeName() } ?.toTypedArray() ?: return@runCatching type))
+                    }.getOrElse { e ->
+                        when (e) {
+                            is KSTypeNotPresentException -> e.ksType.toClassName()
+                        }
+                        if (e is KSTypesNotPresentException) {
+                            type.parameterizedBy(*e.ksTypes.map { it.toTypeName() }.toTypedArray())
+                        } else {
+                            throw e
+                        }
+                    }.copy(
+                        nullable = it.nullable
+                    )
+                    fun addGetterProperty(
+                        receiver: KClass<*>
+                    ) {
+                        addProperty(
+                            PropertySpec.builder(
+                                it.name,
+                                targetType,
+                            ).apply {
+                                addKdoc(
+                                    """
+                                        @return Definition by key "${it.name}"
+                                    """.trimIndent()
+                                )
+                                getter(
+                                    FunSpec.getterBuilder().apply {
+                                        addCode(
+                                            "return " + (if (it.nullable) {
+                                                "getOrNull"
+                                            } else {
+                                                "get"
+                                            }) + "(named(\"${it.name}\"))"
+                                        )
+                                    }.build()
+                                )
+                                receiver(receiver)
+                            }.build()
+                        )
+                    }
+
+                    addGetterProperty(Scope::class)
+                    addGetterProperty(Koin::class)
+
+                    if (it.generateSingle) {
+                        addFunction(
+                            FunSpec.builder("${it.name}Single").apply {
+                                addKdoc(
+                                    """
+                                        Will register [definition] with [org.koin.core.module.Module.single] and key "${it.name}"
+                                    """.trimIndent()
+                                )
+                                receiver(Module::class)
+                                addParameter(
+                                    ParameterSpec.builder(
+                                        "createdAtStart",
+                                        Boolean::class
+                                    ).apply {
+                                        defaultValue("false")
+                                    }.build()
+                                )
+                                addParameter(
+                                    ParameterSpec.builder(
+                                        "definition",
+                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
+                                    ).build()
+                                )
+                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                                addCode(
+                                    "return single(named(\"${it.name}\"), createdAtStart = createdAtStart, definition = definition)"
+                                )
+                            }.build()
+                        )
+                    }
+
+                    if (it.generateFactory) {
+                        addFunction(
+                            FunSpec.builder("${it.name}Factory").apply {
+                                addKdoc(
+                                    """
+                                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${it.name}"
+                                    """.trimIndent()
+                                )
+                                receiver(Module::class)
+                                addParameter(
+                                    ParameterSpec.builder(
+                                        "definition",
+                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
+                                    ).build()
+                                )
+                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                                addCode(
+                                    "return factory(named(\"${it.name}\"), definition = definition)"
+                                )
+                            }.build()
+                        )
+                    }
+                    addImport("org.koin.core.qualifier", "named")
+                }
+            }.build().let {
+                File(
+                    File(ksFile.filePath).parent,
+                    "GeneratedDefinitions${ksFile.fileName}"
+                ).takeIf { !it.exists() } ?.apply {
+                    parentFile.mkdirs()
+
+                    writer().use { writer ->
+                        it.writeTo(writer)
+                    }
+                }
+            }
+        }
+
+        return emptyList()
+    }
+}

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

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

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

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

koin/generator/test/build.gradle

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

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

@@ -0,0 +1,38 @@
+// THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
+// TO REGENERATE IT JUST DELETE FILE
+// ORIGINAL FILE: Test.kt
+package dev.inmo.micro_utils.koin.generator.test
+
+import kotlin.Boolean
+import kotlin.String
+import org.koin.core.Koin
+import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
+import org.koin.core.module.Module
+import org.koin.core.qualifier.named
+import org.koin.core.scope.Scope
+
+/**
+ * @return Definition by key "sampleInfo"
+ */
+public val Scope.sampleInfo: Test<String>
+  get() = get(named("sampleInfo"))
+
+/**
+ * @return Definition by key "sampleInfo"
+ */
+public val Koin.sampleInfo: Test<String>
+  get() = get(named("sampleInfo"))
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
+ */
+public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
+    definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
+ */
+public fun Module.sampleInfoFactory(definition: Definition<Test<String>>):
+    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)

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

@@ -0,0 +1,13 @@
+@file:GenerateKoinDefinition("sampleInfo", Test::class, String::class, nullable = false)
+package dev.inmo.micro_utils.koin.generator.test
+
+import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
+import org.koin.core.Koin
+
+class Test<T>(
+    koin: Koin
+) {
+    init {
+        koin.sampleInfo
+    }
+}

koin/generator/test/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.koin.generator.test"/>

koin/src/commonMain/kotlin/annotations/GenerateKoinDefinition.kt

@@ -0,0 +1,28 @@
+package dev.inmo.micro_utils.koin.annotations
+
+import kotlin.reflect.KClass
+
+/**
+ * Use this annotation to mark files near to which generator should place generated extensions for koin [org.koin.core.scope.Scope]
+ * and [org.koin.core.Koin]
+ *
+ * @param name Name for definitions. This name will be available as extension for [org.koin.core.scope.Scope] and [org.koin.core.Koin]
+ * @param type Type of extensions. It is base star-typed class
+ * @param typeArgs Generic types for [type]. For example, if [type] == `Something::class` and [typeArgs] == `G1::class,
+ * G2::class`, the result type will be `Something<G1, G2>`
+ * @param nullable In case when true, extension will not throw error when definition has not been registered in koin
+ * @param generateSingle Generate definition factory with [org.koin.core.module.Module.single]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Single(createdAtStart/* default false */) { /* your definition */ }
+ * @param generateFactory Generate definition factory with [org.koin.core.module.Module.factory]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Factory { /* your definition */ }
+ */
+@Target(AnnotationTarget.FILE)
+@Repeatable
+annotation class GenerateKoinDefinition(
+    val name: String,
+    val type: KClass<*>,
+    vararg val typeArgs: KClass<*>,
+    val nullable: Boolean = true,
+    val generateSingle: Boolean = true,
+    val generateFactory: Boolean = true
+)

koin/src/jvmMain/kotlin/FactoryWithBinds.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import org.koin.core.qualifier.Qualifier
@@ -13,7 +14,7 @@ inline fun <reified T : Any> Module.factoryWithBinds(
     qualifier: Qualifier? = null,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return factory(qualifier, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 
@@ -21,7 +22,7 @@ inline fun <reified T : Any> Module.factoryWithBinds(
     qualifier: String,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return factory(qualifier, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 

koin/src/jvmMain/kotlin/FactoryWithBindsAndRandomQualifier.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import kotlin.reflect.KClass
@@ -8,6 +9,6 @@ import kotlin.reflect.KClass
 inline fun <reified T : Any> Module.factoryWithRandomQualifierAndBinds(
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return factoryWithBinds(RandomQualifier(), bindFilter, definition)
 }

koin/src/jvmMain/kotlin/SignleWithBinds.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import org.koin.core.qualifier.Qualifier
@@ -14,7 +15,7 @@ inline fun <reified T : Any> Module.singleWithBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return single(qualifier, createdAtStart, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 
@@ -24,7 +25,7 @@ inline fun <reified T : Any> Module.singleWithBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return single(qualifier, createdAtStart, definition) binds (T::class.allSuperclasses.filter(bindFilter).toTypedArray())
 }
 

koin/src/jvmMain/kotlin/SingleWithBindsAndRandomQualifier.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.koin
 
 import org.koin.core.definition.Definition
+import org.koin.core.definition.KoinDefinition
 import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.Module
 import kotlin.reflect.KClass
@@ -9,6 +10,6 @@ inline fun <reified T : Any> Module.singleWithRandomQualifierAndBinds(
     createdAtStart: Boolean = false,
     bindFilter: (KClass<*>) -> Boolean = { true },
     noinline definition: Definition<T>
-): Pair<Module, InstanceFactory<*>> {
+): KoinDefinition<*> {
     return singleWithBinds(RandomQualifier(), createdAtStart, bindFilter, definition)
 }

ktor/client/build.gradle

@@ -15,5 +15,8 @@ kotlin {
                 api libs.ktor.client
             }
         }
+        androidMain {
+            dependsOn jvmMain
+        }
     }
 }

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

@@ -4,6 +4,10 @@ import io.ktor.client.call.body
 import io.ktor.client.statement.HttpResponse
 import io.ktor.http.HttpStatusCode
 
-suspend inline fun <reified T : Any> HttpResponse.bodyOrNull() = takeIf {
-    status == HttpStatusCode.OK
-} ?.body<T>()
+suspend inline fun <reified T : Any> HttpResponse.bodyOrNull(
+    statusFilter: (HttpResponse) -> Boolean = { it.status == HttpStatusCode.OK }
+) = takeIf(statusFilter) ?.body<T>()
+
+suspend inline fun <reified T : Any> HttpResponse.bodyOrNullOnNoContent() = bodyOrNull<T> {
+    it.status != HttpStatusCode.NoContent
+}

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

@@ -19,7 +19,7 @@ import kotlinx.coroutines.isActive
  * connection. Must return true in case if must be reconnected. By default always reconnecting
  */
 @Warning("This feature is internal and should not be used directly. It is can be changed without any notification and warranty on compile-time or other guaranties")
-inline fun <reified T : Any> openBaseWebSocketFlow(
+inline fun <T : Any> openBaseWebSocketFlow(
     noinline checkReconnection: suspend (Throwable?) -> Boolean = { true },
     noinline webSocketSessionRequest: suspend SendChannel<T>.() -> Unit
 ): Flow<T> {
@@ -57,7 +57,7 @@ inline fun <reified T : Any> HttpClient.openWebSocketFlow(
 ): Flow<T> {
     pluginOrNull(WebSockets) ?: error("Plugin $WebSockets must be installed for using createStandardWebsocketFlow")
 
-    return openBaseWebSocketFlow<T>(checkReconnection) {
+    return openBaseWebSocketFlow(checkReconnection) {
         val block: suspend DefaultClientWebSocketSession.() -> Unit = {
             while (isActive) {
                 send(receiveDeserialized<T>())

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

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.ktor.client
+
+typealias OnUploadCallback = suspend (uploaded: Long, count: Long) -> Unit

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

@@ -7,5 +7,5 @@ import io.ktor.client.HttpClient
 expect suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (uploaded: Long, count: Long) -> Unit = { _, _ -> }
+    onUpload: OnUploadCallback = { _, _ -> }
 ): TemporalFileId

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

@@ -0,0 +1,105 @@
+package dev.inmo.micro_utils.ktor.client
+
+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.http.Headers
+import io.ktor.utils.io.core.Input
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.json.Json
+
+data class UniUploadFileInfo(
+    val fileName: FileName,
+    val mimeType: String,
+    val inputAllocator: LambdaInputProvider
+)
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ *
+ * @see dev.inmo.micro_utils.ktor.server.handleUniUpload
+ */
+expect suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T?
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [MPPFile] with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    file: MPPFile,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    additionalData + ("bytes" to file),
+    resultDeserializer,
+    headers,
+    stringFormat,
+    onUpload
+)
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [UniUploadFileInfo] with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    info: UniUploadFileInfo,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    additionalData + ("bytes" to info),
+    resultDeserializer,
+    headers,
+    stringFormat,
+    onUpload
+)
+
+/**
+ * Additional variant of [uniUpload] which will unify sending of some [UniUploadFileInfo] (built from [fileName],
+ * [mimeType] and [inputAllocator]) with the server
+ *
+ * @see dev.inmo.micro_utils.ktor.server.uniloadMultipartFile
+ */
+suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    fileName: FileName,
+    mimeType: String,
+    inputAllocator: LambdaInputProvider,
+    resultDeserializer: DeserializationStrategy<T>,
+    additionalData: Map<String, Any> = emptyMap(),
+    headers: Headers = Headers.Empty,
+    stringFormat: StringFormat = Json,
+    onUpload: OnUploadCallback = { _, _ -> }
+): T? = uniUpload(
+    url,
+    UniUploadFileInfo(fileName, mimeType, inputAllocator),
+    resultDeserializer,
+    additionalData,
+    headers,
+    stringFormat,
+    onUpload
+)

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

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.common.TemporalFileId
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.*
@@ -12,10 +14,11 @@ import org.w3c.xhr.XMLHttpRequest.Companion.DONE
 suspend fun tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (Long, Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val formData = FormData()
     val answer = CompletableDeferred<TemporalFileId>(currentCoroutineContext().job)
+    val subscope = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob())
 
     formData.append(
         "data",
@@ -25,7 +28,7 @@ suspend fun tempUpload(
     val request = XMLHttpRequest()
     request.responseType = XMLHttpRequestResponseType.TEXT
     request.upload.onprogress = {
-        onUpload(it.loaded.toLong(), it.total.toLong())
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
     }
     request.onload = {
         if (request.status == 200.toShort()) {
@@ -48,12 +51,14 @@ suspend fun tempUpload(
         }
     }
 
-    return answer.await()
+    return answer.await().also {
+        subscope.cancel()
+    }
 }
 
 
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (uploaded: Long, count: Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId = dev.inmo.micro_utils.ktor.client.tempUpload(fullTempUploadDraftPath, file, onUpload)

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

@@ -0,0 +1,97 @@
+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.http.Headers
+import io.ktor.utils.io.core.readBytes
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.job
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.encodeToString
+import org.khronos.webgl.Int8Array
+import org.w3c.files.Blob
+import org.w3c.xhr.FormData
+import org.w3c.xhr.TEXT
+import org.w3c.xhr.XMLHttpRequest
+import org.w3c.xhr.XMLHttpRequestResponseType
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ * @suppress
+ */
+actual suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers,
+    stringFormat: StringFormat,
+    onUpload: OnUploadCallback
+): T? {
+    val formData = FormData()
+    val answer = CompletableDeferred<T?>(currentCoroutineContext().job)
+    val subscope = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob())
+
+    data.forEach { (k, v) ->
+        when (v) {
+            is MPPFile -> formData.append(
+                k,
+                v
+            )
+            is UniUploadFileInfo -> formData.append(
+                k,
+                Blob(arrayOf(Int8Array(v.inputAllocator().readBytes().toTypedArray()))),
+                v.fileName.name
+            )
+            else -> formData.append(
+                k,
+                stringFormat.encodeToString(v)
+            )
+        }
+    }
+
+    val request = XMLHttpRequest()
+    headers.forEach { s, strings ->
+        request.setRequestHeader(s, strings.joinToString())
+    }
+    request.responseType = XMLHttpRequestResponseType.TEXT
+    request.upload.onprogress = {
+        subscope.launchSafelyWithoutExceptions { onUpload(it.loaded.toLong(), it.total.toLong()) }
+    }
+    request.onload = {
+        if (request.status == 200.toShort()) {
+            answer.complete(
+                stringFormat.decodeFromString(resultDeserializer, request.responseText)
+            )
+        } else {
+            answer.completeExceptionally(Exception("Something went wrong: $it"))
+        }
+    }
+    request.onerror = {
+        answer.completeExceptionally(Exception("Something went wrong: $it"))
+    }
+    request.open("POST", url, true)
+    request.send(formData)
+
+    answer.invokeOnCompletion {
+        runCatching {
+            if (request.readyState != XMLHttpRequest.DONE) {
+                request.abort()
+            }
+        }
+    }
+
+    return answer.await().also {
+        subscope.cancel()
+    }
+}

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

@@ -4,6 +4,8 @@ import dev.inmo.micro_utils.common.MPPFile
 import io.ktor.client.request.forms.InputProvider
 import io.ktor.utils.io.streams.asInput
 
-actual suspend fun MPPFile.inputProvider(): InputProvider = InputProvider(length()) {
+fun MPPFile.inputProviderSync(): InputProvider = InputProvider(length()) {
     inputStream().asInput()
 }
+
+actual suspend fun MPPFile.inputProvider(): InputProvider = inputProviderSync()

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

@@ -18,7 +18,7 @@ internal val MPPFile.mimeType: String
 actual suspend fun HttpClient.tempUpload(
     fullTempUploadDraftPath: String,
     file: MPPFile,
-    onUpload: (Long, Long) -> Unit
+    onUpload: OnUploadCallback
 ): TemporalFileId {
     val inputProvider = file.inputProvider()
     val fileId = submitFormWithBinaryData(

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

@@ -0,0 +1,107 @@
+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.plugins.onUpload
+import io.ktor.client.request.HttpRequestBuilder
+import io.ktor.client.request.forms.InputProvider
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitForm
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.request.headers
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.Parameters
+import io.ktor.http.content.PartData
+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
+
+/**
+ * Will execute submitting of multipart data request
+ *
+ * @param data [Map] where keys will be used as names for multipart parts and values as values. If you will pass
+ * [dev.inmo.micro_utils.common.MPPFile] (File from JS or JVM platform). Also you may pass [UniUploadFileInfo] as value
+ * in case you wish to pass other source of multipart binary data than regular file
+ * @suppress
+ */
+@OptIn(InternalSerializationApi::class)
+actual suspend fun <T> HttpClient.uniUpload(
+    url: String,
+    data: Map<String, Any>,
+    resultDeserializer: DeserializationStrategy<T>,
+    headers: Headers,
+    stringFormat: StringFormat,
+    onUpload: OnUploadCallback
+): T? {
+    val withBinary = data.values.any { it is File || it is UniUploadFileInfo }
+
+    val formData = formData {
+        for (k in data.keys) {
+            val v = data[k] ?: continue
+            when (v) {
+                is File -> append(
+                    k,
+                    v.inputProviderSync(),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.name}\"")
+                    }
+                )
+                is UniUploadFileInfo -> append(
+                    k,
+                    InputProvider(block = v.inputAllocator),
+                    Headers.build {
+                        append(HttpHeaders.ContentType, v.mimeType)
+                        append(HttpHeaders.ContentDisposition, "filename=\"${v.fileName.name}\"")
+                    }
+                )
+                else -> append(
+                    k,
+                    stringFormat.encodeToString(v::class.serializer() as SerializationStrategy<in Any>, v)
+                )
+            }
+        }
+    }
+
+    val requestBuilder: HttpRequestBuilder.() -> Unit = {
+        headers {
+            appendAll(headers)
+        }
+        onUpload { bytesSentTotal, contentLength ->
+            onUpload(bytesSentTotal, contentLength)
+        }
+    }
+
+    val response = if (withBinary) {
+        submitFormWithBinaryData(
+            url,
+            formData,
+            block = requestBuilder
+        )
+    } else {
+        submitForm(
+            url,
+            Parameters.build {
+                for (it in formData) {
+                    val formItem = (it as PartData.FormItem)
+                    append(it.name!!, it.value)
+                }
+            },
+            block = requestBuilder
+        )
+    }
+
+    return if (response.status == HttpStatusCode.OK) {
+        stringFormat.decodeFromString(resultDeserializer, response.bodyAsText())
+    } else {
+        null
+    }
+}

ktor/common/build.gradle

@@ -17,5 +17,8 @@ kotlin {
                 api libs.ktor.io
             }
         }
+        androidMain {
+            dependsOn jvmMain
+        }
     }
 }

ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/ktor/common/InputProvider.kt

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.ktor.common
+
+import io.ktor.utils.io.core.Input
+
+typealias LambdaInputProvider = () -> Input

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

@@ -0,0 +1,23 @@
+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 java.io.File
+import java.io.InputStream
+import java.util.UUID
+
+fun Input.downloadToTempFile(
+    fileName: String = UUID.randomUUID().toString(),
+    fileExtension: String? = ".temp",
+    folder: File? = null
+) = File.createTempFile(
+    fileName,
+    fileExtension,
+    folder
+).apply {
+    outputStream().use {
+        copyTo(it.asOutput())
+    }
+    deleteOnExit()
+}

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

@@ -0,0 +1,56 @@
+package dev.inmo.micro_utils.ktor.server
+
+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 java.io.File
+
+fun PartData.FileItem.download(target: File) {
+    provider().use { input ->
+        target.outputStream().asOutput().use {
+            input.copyTo(it)
+        }
+    }
+}
+
+fun PartData.FileItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}
+
+fun PartData.BinaryItem.download(target: File) {
+    provider().use { input ->
+        target.outputStream().use {
+            input.copyTo(it.asOutput())
+        }
+    }
+}
+
+fun PartData.BinaryItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}
+
+suspend fun PartData.BinaryChannelItem.download(target: File) {
+    val input = provider()
+    target.outputStream().use {
+        input.copyTo(it)
+    }
+}
+
+suspend fun PartData.BinaryChannelItem.downloadToTemporalFile(): File {
+    val outputFile = File.createTempFile(uuid4().toString(), ".temp").apply {
+        deleteOnExit()
+    }
+    download(outputFile)
+    return outputFile
+}

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

@@ -0,0 +1,25 @@
+package dev.inmo.micro_utils.ktor.server
+
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.respond
+
+suspend fun ApplicationCall.getParameterOrSendError(
+    field: String
+) = parameters[field].also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request must contains $field")
+    }
+}
+
+fun ApplicationCall.getQueryParameter(
+    field: String
+) = request.queryParameters[field]
+
+suspend fun ApplicationCall.getQueryParameterOrSendError(
+    field: String
+) = getQueryParameter(field).also {
+    if (it == null) {
+        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+    }
+}

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

@@ -1,111 +0,0 @@
-package dev.inmo.micro_utils.ktor.server
-
-import dev.inmo.micro_utils.common.*
-import dev.inmo.micro_utils.coroutines.safely
-import dev.inmo.micro_utils.ktor.common.*
-import io.ktor.http.*
-import io.ktor.http.content.*
-import io.ktor.server.application.ApplicationCall
-import io.ktor.server.application.call
-import io.ktor.server.request.receive
-import io.ktor.server.request.receiveMultipart
-import io.ktor.server.response.respond
-import io.ktor.server.response.respondBytes
-import io.ktor.server.routing.Route
-import io.ktor.server.websocket.WebSocketServerSession
-import io.ktor.util.pipeline.PipelineContext
-import io.ktor.utils.io.core.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
-
-suspend fun ApplicationCall.uniloadMultipart(
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
-) = safely {
-    val multipartData = receiveMultipart()
-
-    var resultInput: Input? = null
-
-    multipartData.forEachPart {
-        when (it) {
-            is PartData.FormItem -> onFormItem(it)
-            is PartData.FileItem -> {
-                when (it.name) {
-                    "bytes" -> resultInput = it.provider()
-                    else -> onCustomFileItem(it)
-                }
-            }
-            is PartData.BinaryItem -> onBinaryContent(it)
-            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
-        }
-    }
-
-    resultInput ?: error("Bytes has not been received")
-}
-
-suspend fun ApplicationCall.uniloadMultipartFile(
-    onFormItem: (PartData.FormItem) -> Unit = {},
-    onCustomFileItem: (PartData.FileItem) -> Unit = {},
-    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
-    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
-) = safely {
-    val multipartData = receiveMultipart()
-
-    var resultInput: MPPFile? = null
-
-    multipartData.forEachPart {
-        when (it) {
-            is PartData.FormItem -> onFormItem(it)
-            is PartData.FileItem -> {
-                if (it.name == "bytes") {
-                    val name = FileName(it.originalFileName ?: error("File name is unknown for default part"))
-                    resultInput = MPPFile.createTempFile(
-                        name.nameWithoutExtension.let {
-                            var resultName = it
-                            while (resultName.length < 3) {
-                                resultName += "_"
-                            }
-                            resultName
-                        },
-                        ".${name.extension}"
-                    ).apply {
-                        outputStream().use { fileStream ->
-                            it.streamProvider().use {
-                                it.copyTo(fileStream)
-                            }
-                        }
-                    }
-                } else {
-                    onCustomFileItem(it)
-                }
-            }
-            is PartData.BinaryItem -> onBinaryContent(it)
-            is PartData.BinaryChannelItem -> onBinaryChannelItem(it)
-        }
-    }
-
-    resultInput ?: error("Bytes has not been received")
-}
-
-suspend fun ApplicationCall.getParameterOrSendError(
-    field: String
-) = parameters[field].also {
-    if (it == null) {
-        respond(HttpStatusCode.BadRequest, "Request must contains $field")
-    }
-}
-
-fun ApplicationCall.getQueryParameter(
-    field: String
-) = request.queryParameters[field]
-
-suspend fun ApplicationCall.getQueryParameterOrSendError(
-    field: String
-) = getQueryParameter(field).also {
-    if (it == null) {
-        respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
-    }
-}

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

@@ -0,0 +1,70 @@
+package dev.inmo.micro_utils.ktor.server
+
+import dev.inmo.micro_utils.common.*
+import dev.inmo.micro_utils.coroutines.safely
+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.core.*
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.isActive
+
+/**
+ * Server-side part which receives [dev.inmo.micro_utils.ktor.client.uniUpload] request
+ */
+suspend inline fun ApplicationCall.handleUniUpload(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onFileItem: (PartData.FileItem) -> Unit = {}
+) {
+    val multipartData = receiveMultipart()
+
+    while (currentCoroutineContext().isActive) {
+        val partData = multipartData.readPart() ?: break
+        when (partData) {
+            is PartData.FormItem -> onFormItem(partData)
+            is PartData.FileItem -> onFileItem(partData)
+            is PartData.BinaryItem -> onBinaryContent(partData)
+            is PartData.BinaryChannelItem -> onBinaryChannelItem(partData)
+        }
+        partData.dispose()
+    }
+}
+
+suspend fun ApplicationCall.uniloadMultipart(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {}
+): Input = safely {
+    var resultInput: Input? = null
+
+    handleUniUpload(
+        onFormItem,
+        onBinaryContent,
+        onBinaryChannelItem
+    ) {
+        when (it.name) {
+            "bytes" -> resultInput = it.provider()
+            else -> onCustomFileItem(it)
+        }
+    }
+
+    resultInput ?: error("Bytes has not been received")
+}
+
+suspend fun ApplicationCall.uniloadMultipartFile(
+    onFormItem: (PartData.FormItem) -> Unit = {},
+    onCustomFileItem: (PartData.FileItem) -> Unit = {},
+    onBinaryChannelItem: (PartData.BinaryChannelItem) -> Unit = {},
+    onBinaryContent: (PartData.BinaryItem) -> Unit = {},
+): MPPFile = safely {
+    uniloadMultipart(
+        onFormItem,
+        onCustomFileItem,
+        onBinaryChannelItem,
+        onBinaryContent
+    ).downloadToTempFile()
+}

language_codes/build.gradle

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

language_codes/generator/src/main/kotlin/Main.kt

@@ -78,12 +78,14 @@ private fun printLanguageCodeAndTags(
     indents: String = "    "
 ): String = if (tag.subtags.isEmpty()) {
 """${indents}${baseClassSerializerAnnotationName}
-${indents}object ${tag.title} : ${parent ?.title ?: baseClassName}() { override val code: String = "${tag.tag}" }"""
+${indents}object ${tag.title} : ${parent ?.title ?: baseClassName}() { override val code: String = "${tag.tag}"; override val withoutDialect: String get() = ${parent ?.title ?.let { "$it.code" } ?: "code"} }"""
 } else {
 """
 ${indents}${baseClassSerializerAnnotationName}
 ${indents}sealed class ${tag.title} : ${parent ?.title ?: baseClassName}() {
 ${indents}    override val code: String = "${tag.tag}"
+${indents}    override val withoutDialect: String
+${indents}        get() = code
 
 ${tag.subtags.joinToString("\n") { printLanguageCodeAndTags(it, tag, "${indents}    ") }}
 
@@ -104,11 +106,14 @@ import kotlinx.serialization.Serializable
 ${baseClassSerializerAnnotationName}
 sealed class $baseClassName {
     abstract val code: String
+    abstract val withoutDialect: String
 
 ${tags.joinToString("\n") { printLanguageCodeAndTags(it, indents = "    ") } }
 
     $baseClassSerializerAnnotationName
-    data class $unknownBaseClassName (override val code: String) : $baseClassName()
+    data class $unknownBaseClassName (override val code: String) : $baseClassName() {
+        override val withoutDialect: String = code.takeWhile { it != '-' }
+    }
 
     override fun toString() = code
 }

language_codes/src/jvmMain/kotlin/Locale.kt

@@ -0,0 +1,8 @@
+package dev.inmo.micro_utils.language_codes
+
+import java.util.Locale
+
+fun IetfLanguageCode.toJavaLocale(): Locale = Locale.forLanguageTag(code)
+fun IetfLanguageCode?.toJavaLocaleOrDefault(): Locale = this ?.toJavaLocale() ?: Locale.getDefault()
+
+fun Locale.toIetfLanguageCode(): IetfLanguageCode = IetfLanguageCode(toLanguageTag())

mime_types/mimes_generator/mime_generator.py

@@ -17,10 +17,11 @@ def fix_name(category, raw_name):
         result += out1
     return result
 
+# https://www.freeformatter.com/mime-types-list.html
 if __name__ == '__main__':
     df = pd.read_html(open('table.html', 'r'))
     mimes = []
-    for row in df[0].iterrows():
+    for row in df[0].drop_duplicates(subset=['MIME Type / Internet Media Type'], keep='first').iterrows():
         mime = row[1][1]
         mime_category = mime.split('/', 1)[0]
         mime_name = mime.split('/', 1)[1]
@@ -37,7 +38,7 @@ if __name__ == '__main__':
     code2 = 'internal val knownMimeTypes: Set<MimeType> = setOf(\n'
     code2 += '    KnownMimeTypes.Any,\n'
     for key, group in grouped:
-        group_name = key.capitalize()
+        group_name = fix_name(group, key)
         code += '@Serializable(MimeTypeSerializer::class)\nsealed class %s(raw: String) : MimeType, KnownMimeTypes(raw) {\n' % group_name
         code += '    @Serializable(MimeTypeSerializer::class)\n    object Any: %s ("%s/*")\n' % (group_name, key)
         for mime in group:

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/CustomMimeType.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.mime_types
+
+data class CustomMimeType(override val raw: String) : MimeType

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/KnownMimeTypesSet.kt

@@ -0,0 +1,705 @@
+package dev.inmo.micro_utils.mime_types
+
+internal val knownMimeTypes: Set<MimeType> = setOf(
+    KnownMimeTypes.Any,
+    KnownMimeTypes.Application.VndHzn3dCrossword,
+    KnownMimeTypes.Application.VndMseq,
+    KnownMimeTypes.Application.Vnd3mPostItNotes,
+    KnownMimeTypes.Application.Vnd3gppPicBwLarge,
+    KnownMimeTypes.Application.Vnd3gppPicBwSmall,
+    KnownMimeTypes.Application.Vnd3gppPicBwVar,
+    KnownMimeTypes.Application.Vnd3gpp2Tcap,
+    KnownMimeTypes.Application.X7zCompressed,
+    KnownMimeTypes.Application.XAbiword,
+    KnownMimeTypes.Application.XAceCompressed,
+    KnownMimeTypes.Application.VndAmericandynamicsAcc,
+    KnownMimeTypes.Application.VndAcucobol,
+    KnownMimeTypes.Application.VndAcucorp,
+    KnownMimeTypes.Application.XAuthorwareBin,
+    KnownMimeTypes.Application.XAuthorwareMap,
+    KnownMimeTypes.Application.XAuthorwareSeg,
+    KnownMimeTypes.Application.VndAdobeAirApplicationInstallerPackageZip,
+    KnownMimeTypes.Application.XShockwaveFlash,
+    KnownMimeTypes.Application.VndAdobeFxp,
+    KnownMimeTypes.Application.Pdf,
+    KnownMimeTypes.Application.VndCupsPpd,
+    KnownMimeTypes.Application.XDirector,
+    KnownMimeTypes.Application.VndAdobeXdpXml,
+    KnownMimeTypes.Application.VndAdobeXfdf,
+    KnownMimeTypes.Application.VndAheadSpace,
+    KnownMimeTypes.Application.VndAirzipFilesecureAzf,
+    KnownMimeTypes.Application.VndAirzipFilesecureAzs,
+    KnownMimeTypes.Application.VndAmazonEbook,
+    KnownMimeTypes.Application.VndAmigaAmi,
+    KnownMimeTypes.Application.AndrewInset,
+    KnownMimeTypes.Application.VndAndroidPackageArchive,
+    KnownMimeTypes.Application.VndAnserWebCertificateIssueInitiation,
+    KnownMimeTypes.Application.VndAnserWebFundsTransferInitiation,
+    KnownMimeTypes.Application.VndAntixGameComponent,
+    KnownMimeTypes.Application.XAppleDiskimage,
+    KnownMimeTypes.Application.VndAppleInstallerXml,
+    KnownMimeTypes.Application.Applixware,
+    KnownMimeTypes.Application.VndHheLessonPlayer,
+    KnownMimeTypes.Application.XFreearc,
+    KnownMimeTypes.Application.VndAristanetworksSwi,
+    KnownMimeTypes.Application.AtomcatXml,
+    KnownMimeTypes.Application.AtomsvcXml,
+    KnownMimeTypes.Application.AtomXml,
+    KnownMimeTypes.Application.PkixAttrCert,
+    KnownMimeTypes.Application.VndAudiograph,
+    KnownMimeTypes.Application.XBcpio,
+    KnownMimeTypes.Application.OctetStream,
+    KnownMimeTypes.Application.XBittorrent,
+    KnownMimeTypes.Application.VndRimCod,
+    KnownMimeTypes.Application.VndBlueiceMultipass,
+    KnownMimeTypes.Application.VndBmi,
+    KnownMimeTypes.Application.XSh,
+    KnownMimeTypes.Application.VndBusinessobjects,
+    KnownMimeTypes.Application.XBzip,
+    KnownMimeTypes.Application.XBzip2,
+    KnownMimeTypes.Application.XCsh,
+    KnownMimeTypes.Application.VndChemdrawXml,
+    KnownMimeTypes.Application.XCdf,
+    KnownMimeTypes.Application.VndContactCmsg,
+    KnownMimeTypes.Application.VndClaymore,
+    KnownMimeTypes.Application.VndClonkC4group,
+    KnownMimeTypes.Application.CdmiCapability,
+    KnownMimeTypes.Application.CdmiContainer,
+    KnownMimeTypes.Application.CdmiDomain,
+    KnownMimeTypes.Application.CdmiObject,
+    KnownMimeTypes.Application.CdmiQueue,
+    KnownMimeTypes.Application.VndCluetrustCartomobileConfig,
+    KnownMimeTypes.Application.VndCluetrustCartomobileConfigPkg,
+    KnownMimeTypes.Application.MacCompactpro,
+    KnownMimeTypes.Application.VndWapWmlc,
+    KnownMimeTypes.Application.VndXara,
+    KnownMimeTypes.Application.VndCosmocaller,
+    KnownMimeTypes.Application.XCpio,
+    KnownMimeTypes.Application.VndCrickClicker,
+    KnownMimeTypes.Application.VndCrickClickerKeyboard,
+    KnownMimeTypes.Application.VndCrickClickerPalette,
+    KnownMimeTypes.Application.VndCrickClickerTemplate,
+    KnownMimeTypes.Application.VndCrickClickerWordbank,
+    KnownMimeTypes.Application.VndCriticaltoolsWbsXml,
+    KnownMimeTypes.Application.VndRigCryptonote,
+    KnownMimeTypes.Application.CuSeeme,
+    KnownMimeTypes.Application.PrsCww,
+    KnownMimeTypes.Application.VndCurlCar,
+    KnownMimeTypes.Application.VndCurlPcurl,
+    KnownMimeTypes.Application.VndYellowriverCustomMenu,
+    KnownMimeTypes.Application.DsscDer,
+    KnownMimeTypes.Application.DsscXml,
+    KnownMimeTypes.Application.XDebianPackage,
+    KnownMimeTypes.Application.XDvi,
+    KnownMimeTypes.Application.VndFdsnSeed,
+    KnownMimeTypes.Application.XDtbookXml,
+    KnownMimeTypes.Application.XDtbresourceXml,
+    KnownMimeTypes.Application.VndDvbAit,
+    KnownMimeTypes.Application.VndDvbService,
+    KnownMimeTypes.Application.XmlDtd,
+    KnownMimeTypes.Application.VndDolbyMlp,
+    KnownMimeTypes.Application.XDoom,
+    KnownMimeTypes.Application.VndDpgraph,
+    KnownMimeTypes.Application.VndDreamfactory,
+    KnownMimeTypes.Application.VndDynageo,
+    KnownMimeTypes.Application.Ecmascript,
+    KnownMimeTypes.Application.VndEcowinChart,
+    KnownMimeTypes.Application.Exi,
+    KnownMimeTypes.Application.VndProteusMagazine,
+    KnownMimeTypes.Application.EpubZip,
+    KnownMimeTypes.Application.VndEnliven,
+    KnownMimeTypes.Application.VndIsXpr,
+    KnownMimeTypes.Application.VndXfdl,
+    KnownMimeTypes.Application.EmmaXml,
+    KnownMimeTypes.Application.VndEzpixAlbum,
+    KnownMimeTypes.Application.VndEzpixPackage,
+    KnownMimeTypes.Application.VndDenovoFcselayoutLink,
+    KnownMimeTypes.Application.VndFluxtimeClip,
+    KnownMimeTypes.Application.VndFdf,
+    KnownMimeTypes.Application.VndMif,
+    KnownMimeTypes.Application.VndFramemaker,
+    KnownMimeTypes.Application.VndFscWeblaunch,
+    KnownMimeTypes.Application.VndFrogansFnc,
+    KnownMimeTypes.Application.VndFrogansLtf,
+    KnownMimeTypes.Application.VndFujixeroxDdd,
+    KnownMimeTypes.Application.VndFujixeroxDocuworks,
+    KnownMimeTypes.Application.VndFujixeroxDocuworksBinder,
+    KnownMimeTypes.Application.VndFujitsuOasys,
+    KnownMimeTypes.Application.VndFujitsuOasys2,
+    KnownMimeTypes.Application.VndFujitsuOasys3,
+    KnownMimeTypes.Application.VndFujitsuOasysgp,
+    KnownMimeTypes.Application.VndFujitsuOasysprs,
+    KnownMimeTypes.Application.XFuturesplash,
+    KnownMimeTypes.Application.VndFuzzysheet,
+    KnownMimeTypes.Application.VndGmx,
+    KnownMimeTypes.Application.VndGenomatixTuxedo,
+    KnownMimeTypes.Application.VndGeogebraFile,
+    KnownMimeTypes.Application.VndGeogebraTool,
+    KnownMimeTypes.Application.VndGeometryExplorer,
+    KnownMimeTypes.Application.VndGeonext,
+    KnownMimeTypes.Application.VndGeoplan,
+    KnownMimeTypes.Application.VndGeospace,
+    KnownMimeTypes.Application.XFontGhostscript,
+    KnownMimeTypes.Application.XFontBdf,
+    KnownMimeTypes.Application.XGtar,
+    KnownMimeTypes.Application.XTexinfo,
+    KnownMimeTypes.Application.XGnumeric,
+    KnownMimeTypes.Application.VndGoogleEarthKmlXml,
+    KnownMimeTypes.Application.VndGoogleEarthKmz,
+    KnownMimeTypes.Application.GpxXml,
+    KnownMimeTypes.Application.VndGrafeq,
+    KnownMimeTypes.Application.VndGrooveAccount,
+    KnownMimeTypes.Application.VndGrooveHelp,
+    KnownMimeTypes.Application.VndGrooveIdentityMessage,
+    KnownMimeTypes.Application.VndGrooveInjector,
+    KnownMimeTypes.Application.VndGrooveToolMessage,
+    KnownMimeTypes.Application.VndGrooveToolTemplate,
+    KnownMimeTypes.Application.VndGrooveVcard,
+    KnownMimeTypes.Application.Gzip,
+    KnownMimeTypes.Application.VndHpHpid,
+    KnownMimeTypes.Application.VndHpHps,
+    KnownMimeTypes.Application.XHdf,
+    KnownMimeTypes.Application.VndHbci,
+    KnownMimeTypes.Application.VndHpJlyt,
+    KnownMimeTypes.Application.VndHpPcl,
+    KnownMimeTypes.Application.VndHpHpgl,
+    KnownMimeTypes.Application.VndYamahaHvScript,
+    KnownMimeTypes.Application.VndYamahaHvDic,
+    KnownMimeTypes.Application.VndYamahaHvVoice,
+    KnownMimeTypes.Application.VndHydrostatixSofData,
+    KnownMimeTypes.Application.Hyperstudio,
+    KnownMimeTypes.Application.VndHalXml,
+    KnownMimeTypes.Application.VndIbmRightsManagement,
+    KnownMimeTypes.Application.VndIbmSecureContainer,
+    KnownMimeTypes.Application.VndIccprofile,
+    KnownMimeTypes.Application.VndIgloader,
+    KnownMimeTypes.Application.VndImmervisionIvp,
+    KnownMimeTypes.Application.VndImmervisionIvu,
+    KnownMimeTypes.Application.ReginfoXml,
+    KnownMimeTypes.Application.VndIntergeo,
+    KnownMimeTypes.Application.VndCinderella,
+    KnownMimeTypes.Application.VndInterconFormnet,
+    KnownMimeTypes.Application.VndIsacFcs,
+    KnownMimeTypes.Application.Ipfix,
+    KnownMimeTypes.Application.PkixCert,
+    KnownMimeTypes.Application.Pkixcmp,
+    KnownMimeTypes.Application.PkixCrl,
+    KnownMimeTypes.Application.PkixPkipath,
+    KnownMimeTypes.Application.VndInsorsIgm,
+    KnownMimeTypes.Application.VndIpunpluggedRcprofile,
+    KnownMimeTypes.Application.VndIrepositoryPackageXml,
+    KnownMimeTypes.Application.JavaArchive,
+    KnownMimeTypes.Application.JavaVm,
+    KnownMimeTypes.Application.XJavaJnlpFile,
+    KnownMimeTypes.Application.JavaSerializedObject,
+    KnownMimeTypes.Application.Javascript,
+    KnownMimeTypes.Application.Json,
+    KnownMimeTypes.Application.VndJoostJodaArchive,
+    KnownMimeTypes.Application.LdJson,
+    KnownMimeTypes.Application.VndKahootz,
+    KnownMimeTypes.Application.VndChipnutsKaraokeMmd,
+    KnownMimeTypes.Application.VndKdeKarbon,
+    KnownMimeTypes.Application.VndKdeKchart,
+    KnownMimeTypes.Application.VndKdeKformula,
+    KnownMimeTypes.Application.VndKdeKivio,
+    KnownMimeTypes.Application.VndKdeKontour,
+    KnownMimeTypes.Application.VndKdeKpresenter,
+    KnownMimeTypes.Application.VndKdeKspread,
+    KnownMimeTypes.Application.VndKdeKword,
+    KnownMimeTypes.Application.VndKenameaapp,
+    KnownMimeTypes.Application.VndKidspiration,
+    KnownMimeTypes.Application.VndKinar,
+    KnownMimeTypes.Application.VndKodakDescriptor,
+    KnownMimeTypes.Application.VndLasLasXml,
+    KnownMimeTypes.Application.XLatex,
+    KnownMimeTypes.Application.VndLlamagraphicsLifeBalanceDesktop,
+    KnownMimeTypes.Application.VndLlamagraphicsLifeBalanceExchangeXml,
+    KnownMimeTypes.Application.VndJam,
+    KnownMimeTypes.Application.VndLotus123,
+    KnownMimeTypes.Application.VndLotusApproach,
+    KnownMimeTypes.Application.VndLotusFreelance,
+    KnownMimeTypes.Application.VndLotusNotes,
+    KnownMimeTypes.Application.VndLotusOrganizer,
+    KnownMimeTypes.Application.VndLotusScreencam,
+    KnownMimeTypes.Application.VndLotusWordpro,
+    KnownMimeTypes.Application.MacBinhex40,
+    KnownMimeTypes.Application.VndMacportsPortpkg,
+    KnownMimeTypes.Application.VndOsgeoMapguidePackage,
+    KnownMimeTypes.Application.Marc,
+    KnownMimeTypes.Application.MarcxmlXml,
+    KnownMimeTypes.Application.Mxf,
+    KnownMimeTypes.Application.VndWolframPlayer,
+    KnownMimeTypes.Application.Mathematica,
+    KnownMimeTypes.Application.MathmlXml,
+    KnownMimeTypes.Application.Mbox,
+    KnownMimeTypes.Application.VndMedcalcdata,
+    KnownMimeTypes.Application.MediaservercontrolXml,
+    KnownMimeTypes.Application.VndMediastationCdkey,
+    KnownMimeTypes.Application.VndMfer,
+    KnownMimeTypes.Application.VndMfmp,
+    KnownMimeTypes.Application.MadsXml,
+    KnownMimeTypes.Application.MetsXml,
+    KnownMimeTypes.Application.ModsXml,
+    KnownMimeTypes.Application.Metalink4Xml,
+    KnownMimeTypes.Application.VndMcd,
+    KnownMimeTypes.Application.VndMicrografxFlo,
+    KnownMimeTypes.Application.VndMicrografxIgx,
+    KnownMimeTypes.Application.VndEszigno3Xml,
+    KnownMimeTypes.Application.XMsaccess,
+    KnownMimeTypes.Application.XMsdownload,
+    KnownMimeTypes.Application.VndMsArtgalry,
+    KnownMimeTypes.Application.VndMsCabCompressed,
+    KnownMimeTypes.Application.VndMsIms,
+    KnownMimeTypes.Application.XMsApplication,
+    KnownMimeTypes.Application.XMsclip,
+    KnownMimeTypes.Application.VndMsFontobject,
+    KnownMimeTypes.Application.VndMsExcel,
+    KnownMimeTypes.Application.VndMsExcelAddinMacroenabled12,
+    KnownMimeTypes.Application.VndMsExcelSheetBinaryMacroenabled12,
+    KnownMimeTypes.Application.VndMsExcelTemplateMacroenabled12,
+    KnownMimeTypes.Application.VndMsExcelSheetMacroenabled12,
+    KnownMimeTypes.Application.VndMsHtmlhelp,
+    KnownMimeTypes.Application.XMscardfile,
+    KnownMimeTypes.Application.VndMsLrm,
+    KnownMimeTypes.Application.XMsmediaview,
+    KnownMimeTypes.Application.XMsmoney,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentPresentationmlPresentation,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentPresentationmlSlide,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentPresentationmlSlideshow,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentPresentationmlTemplate,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentSpreadsheetmlSheet,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentWordprocessingmlDocument,
+    KnownMimeTypes.Application.VndOpenxmlformatsOfficedocumentWordprocessingmlTemplate,
+    KnownMimeTypes.Application.XMsbinder,
+    KnownMimeTypes.Application.VndMsOfficetheme,
+    KnownMimeTypes.Application.Onenote,
+    KnownMimeTypes.Application.VndMsPowerpoint,
+    KnownMimeTypes.Application.VndMsPowerpointAddinMacroenabled12,
+    KnownMimeTypes.Application.VndMsPowerpointSlideMacroenabled12,
+    KnownMimeTypes.Application.VndMsPowerpointPresentationMacroenabled12,
+    KnownMimeTypes.Application.VndMsPowerpointSlideshowMacroenabled12,
+    KnownMimeTypes.Application.VndMsPowerpointTemplateMacroenabled12,
+    KnownMimeTypes.Application.VndMsProject,
+    KnownMimeTypes.Application.XMspublisher,
+    KnownMimeTypes.Application.XMsschedule,
+    KnownMimeTypes.Application.XSilverlightApp,
+    KnownMimeTypes.Application.VndMsPkiStl,
+    KnownMimeTypes.Application.VndMsPkiSeccat,
+    KnownMimeTypes.Application.VndVisio,
+    KnownMimeTypes.Application.VndVisio2013,
+    KnownMimeTypes.Application.XMsWmd,
+    KnownMimeTypes.Application.VndMsWpl,
+    KnownMimeTypes.Application.XMsWmz,
+    KnownMimeTypes.Application.XMsmetafile,
+    KnownMimeTypes.Application.XMsterminal,
+    KnownMimeTypes.Application.Msword,
+    KnownMimeTypes.Application.VndMsWordDocumentMacroenabled12,
+    KnownMimeTypes.Application.VndMsWordTemplateMacroenabled12,
+    KnownMimeTypes.Application.XMswrite,
+    KnownMimeTypes.Application.VndMsWorks,
+    KnownMimeTypes.Application.XMsXbap,
+    KnownMimeTypes.Application.VndMsXpsdocument,
+    KnownMimeTypes.Application.VndIbmMinipay,
+    KnownMimeTypes.Application.VndIbmModcap,
+    KnownMimeTypes.Application.VndJcpJavameMidletRms,
+    KnownMimeTypes.Application.VndTmobileLivetv,
+    KnownMimeTypes.Application.XMobipocketEbook,
+    KnownMimeTypes.Application.VndMobiusMbk,
+    KnownMimeTypes.Application.VndMobiusDis,
+    KnownMimeTypes.Application.VndMobiusPlc,
+    KnownMimeTypes.Application.VndMobiusMqy,
+    KnownMimeTypes.Application.VndMobiusMsl,
+    KnownMimeTypes.Application.VndMobiusTxf,
+    KnownMimeTypes.Application.VndMobiusDaf,
+    KnownMimeTypes.Application.VndMophunCertificate,
+    KnownMimeTypes.Application.VndMophunApplication,
+    KnownMimeTypes.Application.Mp21,
+    KnownMimeTypes.Application.Mp4,
+    KnownMimeTypes.Application.VndAppleMpegurl,
+    KnownMimeTypes.Application.VndMusician,
+    KnownMimeTypes.Application.VndMuveeStyle,
+    KnownMimeTypes.Application.XvXml,
+    KnownMimeTypes.Application.VndNokiaNGageData,
+    KnownMimeTypes.Application.VndNokiaNGageSymbianInstall,
+    KnownMimeTypes.Application.XDtbncxXml,
+    KnownMimeTypes.Application.XNetcdf,
+    KnownMimeTypes.Application.VndNeurolanguageNlu,
+    KnownMimeTypes.Application.VndDna,
+    KnownMimeTypes.Application.VndNoblenetDirectory,
+    KnownMimeTypes.Application.VndNoblenetSealer,
+    KnownMimeTypes.Application.VndNoblenetWeb,
+    KnownMimeTypes.Application.VndNokiaRadioPreset,
+    KnownMimeTypes.Application.VndNokiaRadioPresets,
+    KnownMimeTypes.Application.VndNovadigmEdm,
+    KnownMimeTypes.Application.VndNovadigmEdx,
+    KnownMimeTypes.Application.VndNovadigmExt,
+    KnownMimeTypes.Application.VndFlographit,
+    KnownMimeTypes.Application.Oda,
+    KnownMimeTypes.Application.Ogg,
+    KnownMimeTypes.Application.VndOmaDd2Xml,
+    KnownMimeTypes.Application.VndOasisOpendocumentTextWeb,
+    KnownMimeTypes.Application.OebpsPackageXml,
+    KnownMimeTypes.Application.VndIntuQbo,
+    KnownMimeTypes.Application.VndOpenofficeorgExtension,
+    KnownMimeTypes.Application.VndYamahaOpenscoreformat,
+    KnownMimeTypes.Application.VndOasisOpendocumentChart,
+    KnownMimeTypes.Application.VndOasisOpendocumentChartTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentDatabase,
+    KnownMimeTypes.Application.VndOasisOpendocumentFormula,
+    KnownMimeTypes.Application.VndOasisOpendocumentFormulaTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentGraphics,
+    KnownMimeTypes.Application.VndOasisOpendocumentGraphicsTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentImage,
+    KnownMimeTypes.Application.VndOasisOpendocumentImageTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentPresentation,
+    KnownMimeTypes.Application.VndOasisOpendocumentPresentationTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentSpreadsheet,
+    KnownMimeTypes.Application.VndOasisOpendocumentSpreadsheetTemplate,
+    KnownMimeTypes.Application.VndOasisOpendocumentText,
+    KnownMimeTypes.Application.VndOasisOpendocumentTextMaster,
+    KnownMimeTypes.Application.VndOasisOpendocumentTextTemplate,
+    KnownMimeTypes.Application.VndSunXmlCalc,
+    KnownMimeTypes.Application.VndSunXmlCalcTemplate,
+    KnownMimeTypes.Application.VndSunXmlDraw,
+    KnownMimeTypes.Application.VndSunXmlDrawTemplate,
+    KnownMimeTypes.Application.VndSunXmlImpress,
+    KnownMimeTypes.Application.VndSunXmlImpressTemplate,
+    KnownMimeTypes.Application.VndSunXmlMath,
+    KnownMimeTypes.Application.VndSunXmlWriter,
+    KnownMimeTypes.Application.VndSunXmlWriterGlobal,
+    KnownMimeTypes.Application.VndSunXmlWriterTemplate,
+    KnownMimeTypes.Application.XFontOtf,
+    KnownMimeTypes.Application.VndYamahaOpenscoreformatOsfpvgXml,
+    KnownMimeTypes.Application.VndOsgiDp,
+    KnownMimeTypes.Application.VndPalm,
+    KnownMimeTypes.Application.VndPawaafile,
+    KnownMimeTypes.Application.VndHpPclxl,
+    KnownMimeTypes.Application.VndPicsel,
+    KnownMimeTypes.Application.PicsRules,
+    KnownMimeTypes.Application.XChat,
+    KnownMimeTypes.Application.Pkcs10,
+    KnownMimeTypes.Application.XPkcs12,
+    KnownMimeTypes.Application.Pkcs7Mime,
+    KnownMimeTypes.Application.Pkcs7Signature,
+    KnownMimeTypes.Application.XPkcs7Certreqresp,
+    KnownMimeTypes.Application.XPkcs7Certificates,
+    KnownMimeTypes.Application.Pkcs8,
+    KnownMimeTypes.Application.VndPocketlearn,
+    KnownMimeTypes.Application.XFontPcf,
+    KnownMimeTypes.Application.FontTdpfr,
+    KnownMimeTypes.Application.XChessPgn,
+    KnownMimeTypes.Application.PskcXml,
+    KnownMimeTypes.Application.VndCtcPosml,
+    KnownMimeTypes.Application.Postscript,
+    KnownMimeTypes.Application.XFontType1,
+    KnownMimeTypes.Application.VndPowerbuilder6,
+    KnownMimeTypes.Application.PgpEncrypted,
+    KnownMimeTypes.Application.PgpSignature,
+    KnownMimeTypes.Application.VndPreviewsystemsBox,
+    KnownMimeTypes.Application.VndPviPtid1,
+    KnownMimeTypes.Application.PlsXml,
+    KnownMimeTypes.Application.VndPgFormat,
+    KnownMimeTypes.Application.VndPgOsasli,
+    KnownMimeTypes.Application.XFontLinuxPsf,
+    KnownMimeTypes.Application.VndPublishareDeltaTree,
+    KnownMimeTypes.Application.VndPmiWidget,
+    KnownMimeTypes.Application.VndQuarkQuarkxpress,
+    KnownMimeTypes.Application.VndEpsonEsf,
+    KnownMimeTypes.Application.VndEpsonMsf,
+    KnownMimeTypes.Application.VndEpsonSsf,
+    KnownMimeTypes.Application.VndEpsonQuickanime,
+    KnownMimeTypes.Application.VndIntuQfx,
+    KnownMimeTypes.Application.XRarCompressed,
+    KnownMimeTypes.Application.RsdXml,
+    KnownMimeTypes.Application.VndRnRealmedia,
+    KnownMimeTypes.Application.VndRealvncBed,
+    KnownMimeTypes.Application.VndRecordareMusicxml,
+    KnownMimeTypes.Application.VndRecordareMusicxmlXml,
+    KnownMimeTypes.Application.RelaxNgCompactSyntax,
+    KnownMimeTypes.Application.VndDataVisionRdz,
+    KnownMimeTypes.Application.RdfXml,
+    KnownMimeTypes.Application.VndCloantoRp9,
+    KnownMimeTypes.Application.VndJisp,
+    KnownMimeTypes.Application.Rtf,
+    KnownMimeTypes.Application.VndRoute66Link66Xml,
+    KnownMimeTypes.Application.RssXml,
+    KnownMimeTypes.Application.ShfXml,
+    KnownMimeTypes.Application.VndSailingtrackerTrack,
+    KnownMimeTypes.Application.VndSusCalendar,
+    KnownMimeTypes.Application.SruXml,
+    KnownMimeTypes.Application.SetPaymentInitiation,
+    KnownMimeTypes.Application.SetRegistrationInitiation,
+    KnownMimeTypes.Application.VndSema,
+    KnownMimeTypes.Application.VndSemd,
+    KnownMimeTypes.Application.VndSemf,
+    KnownMimeTypes.Application.VndSeemail,
+    KnownMimeTypes.Application.XFontSnf,
+    KnownMimeTypes.Application.ScvpVpRequest,
+    KnownMimeTypes.Application.ScvpVpResponse,
+    KnownMimeTypes.Application.ScvpCvRequest,
+    KnownMimeTypes.Application.ScvpCvResponse,
+    KnownMimeTypes.Application.Sdp,
+    KnownMimeTypes.Application.VndShanaInformedFormdata,
+    KnownMimeTypes.Application.VndShanaInformedFormtemplate,
+    KnownMimeTypes.Application.VndShanaInformedInterchange,
+    KnownMimeTypes.Application.VndShanaInformedPackage,
+    KnownMimeTypes.Application.ThraudXml,
+    KnownMimeTypes.Application.XShar,
+    KnownMimeTypes.Application.VndEpsonSalt,
+    KnownMimeTypes.Application.VndAccpacSimplyAso,
+    KnownMimeTypes.Application.VndAccpacSimplyImp,
+    KnownMimeTypes.Application.VndSimtechMindmapper,
+    KnownMimeTypes.Application.VndCommonspace,
+    KnownMimeTypes.Application.VndYamahaSmafAudio,
+    KnownMimeTypes.Application.VndSmaf,
+    KnownMimeTypes.Application.VndYamahaSmafPhrase,
+    KnownMimeTypes.Application.VndSmartTeacher,
+    KnownMimeTypes.Application.VndSvd,
+    KnownMimeTypes.Application.SparqlQuery,
+    KnownMimeTypes.Application.SparqlResultsXml,
+    KnownMimeTypes.Application.Srgs,
+    KnownMimeTypes.Application.SrgsXml,
+    KnownMimeTypes.Application.SsmlXml,
+    KnownMimeTypes.Application.VndKoan,
+    KnownMimeTypes.Application.VndStardivisionCalc,
+    KnownMimeTypes.Application.VndStardivisionDraw,
+    KnownMimeTypes.Application.VndStardivisionImpress,
+    KnownMimeTypes.Application.VndStardivisionMath,
+    KnownMimeTypes.Application.VndStardivisionWriter,
+    KnownMimeTypes.Application.VndStardivisionWriterGlobal,
+    KnownMimeTypes.Application.VndStepmaniaStepchart,
+    KnownMimeTypes.Application.XStuffit,
+    KnownMimeTypes.Application.XStuffitx,
+    KnownMimeTypes.Application.VndSolentSdkmXml,
+    KnownMimeTypes.Application.VndOlpcSugar,
+    KnownMimeTypes.Application.VndWqd,
+    KnownMimeTypes.Application.VndSymbianInstall,
+    KnownMimeTypes.Application.SmilXml,
+    KnownMimeTypes.Application.VndSyncmlXml,
+    KnownMimeTypes.Application.VndSyncmlDmWbxml,
+    KnownMimeTypes.Application.VndSyncmlDmXml,
+    KnownMimeTypes.Application.XSv4cpio,
+    KnownMimeTypes.Application.XSv4crc,
+    KnownMimeTypes.Application.SbmlXml,
+    KnownMimeTypes.Application.VndTaoIntentModuleArchive,
+    KnownMimeTypes.Application.XTar,
+    KnownMimeTypes.Application.XTcl,
+    KnownMimeTypes.Application.XTex,
+    KnownMimeTypes.Application.XTexTfm,
+    KnownMimeTypes.Application.TeiXml,
+    KnownMimeTypes.Application.VndSpotfireDxp,
+    KnownMimeTypes.Application.VndSpotfireSfs,
+    KnownMimeTypes.Application.TimestampedData,
+    KnownMimeTypes.Application.VndTridTpt,
+    KnownMimeTypes.Application.VndTriscapeMxs,
+    KnownMimeTypes.Application.VndTrueapp,
+    KnownMimeTypes.Application.XFontTtf,
+    KnownMimeTypes.Application.VndUmajin,
+    KnownMimeTypes.Application.VndUomlXml,
+    KnownMimeTypes.Application.VndUnity,
+    KnownMimeTypes.Application.VndUfdl,
+    KnownMimeTypes.Application.VndUiqTheme,
+    KnownMimeTypes.Application.XUstar,
+    KnownMimeTypes.Application.XCdlink,
+    KnownMimeTypes.Application.VndVsf,
+    KnownMimeTypes.Application.VndVcx,
+    KnownMimeTypes.Application.VndVisionary,
+    KnownMimeTypes.Application.CcxmlXml,
+    KnownMimeTypes.Application.VoicexmlXml,
+    KnownMimeTypes.Application.XWaisSource,
+    KnownMimeTypes.Application.VndWapWbxml,
+    KnownMimeTypes.Application.DavmountXml,
+    KnownMimeTypes.Application.XFontWoff,
+    KnownMimeTypes.Application.WspolicyXml,
+    KnownMimeTypes.Application.VndWebturbo,
+    KnownMimeTypes.Application.Widget,
+    KnownMimeTypes.Application.Winhlp,
+    KnownMimeTypes.Application.VndWapWmlscriptc,
+    KnownMimeTypes.Application.VndWordperfect,
+    KnownMimeTypes.Application.VndWtStf,
+    KnownMimeTypes.Application.WsdlXml,
+    KnownMimeTypes.Application.XX509CaCert,
+    KnownMimeTypes.Application.XXfig,
+    KnownMimeTypes.Application.XhtmlXml,
+    KnownMimeTypes.Application.Xml,
+    KnownMimeTypes.Application.XcapDiffXml,
+    KnownMimeTypes.Application.XencXml,
+    KnownMimeTypes.Application.PatchOpsErrorXml,
+    KnownMimeTypes.Application.ResourceListsXml,
+    KnownMimeTypes.Application.RlsServicesXml,
+    KnownMimeTypes.Application.ResourceListsDiffXml,
+    KnownMimeTypes.Application.XsltXml,
+    KnownMimeTypes.Application.XopXml,
+    KnownMimeTypes.Application.XXpinstall,
+    KnownMimeTypes.Application.XspfXml,
+    KnownMimeTypes.Application.VndMozillaXulXml,
+    KnownMimeTypes.Application.Yang,
+    KnownMimeTypes.Application.YinXml,
+    KnownMimeTypes.Application.VndZul,
+    KnownMimeTypes.Application.Zip,
+    KnownMimeTypes.Application.VndHandheldEntertainmentXml,
+    KnownMimeTypes.Application.VndZzazzDeckXml,
+    KnownMimeTypes.Audio.Adpcm,
+    KnownMimeTypes.Audio.XAac,
+    KnownMimeTypes.Audio.XAiff,
+    KnownMimeTypes.Audio.VndDeceAudio,
+    KnownMimeTypes.Audio.VndDigitalWinds,
+    KnownMimeTypes.Audio.VndDra,
+    KnownMimeTypes.Audio.VndDts,
+    KnownMimeTypes.Audio.VndDtsHd,
+    KnownMimeTypes.Audio.VndRip,
+    KnownMimeTypes.Audio.VndLucentVoice,
+    KnownMimeTypes.Audio.XMpegurl,
+    KnownMimeTypes.Audio.VndMsPlayreadyMediaPya,
+    KnownMimeTypes.Audio.XMsWma,
+    KnownMimeTypes.Audio.XMsWax,
+    KnownMimeTypes.Audio.Midi,
+    KnownMimeTypes.Audio.Mpeg,
+    KnownMimeTypes.Audio.Mp4,
+    KnownMimeTypes.Audio.VndNueraEcelp4800,
+    KnownMimeTypes.Audio.VndNueraEcelp7470,
+    KnownMimeTypes.Audio.VndNueraEcelp9600,
+    KnownMimeTypes.Audio.Ogg,
+    KnownMimeTypes.Audio.Webm,
+    KnownMimeTypes.Audio.Opus,
+    KnownMimeTypes.Audio.XPnRealaudio,
+    KnownMimeTypes.Audio.XPnRealaudioPlugin,
+    KnownMimeTypes.Audio.Basic,
+    KnownMimeTypes.Audio.XWav,
+    KnownMimeTypes.Chemical.XCdx,
+    KnownMimeTypes.Chemical.XCml,
+    KnownMimeTypes.Chemical.XCsml,
+    KnownMimeTypes.Chemical.XCif,
+    KnownMimeTypes.Chemical.XCmdf,
+    KnownMimeTypes.Chemical.XXyz,
+    KnownMimeTypes.Image.VndDxf,
+    KnownMimeTypes.Image.Avif,
+    KnownMimeTypes.Image.Bmp,
+    KnownMimeTypes.Image.PrsBtif,
+    KnownMimeTypes.Image.VndDvbSubtitle,
+    KnownMimeTypes.Image.XCmuRaster,
+    KnownMimeTypes.Image.Cgm,
+    KnownMimeTypes.Image.XCmx,
+    KnownMimeTypes.Image.VndDeceGraphic,
+    KnownMimeTypes.Image.VndDjvu,
+    KnownMimeTypes.Image.VndDwg,
+    KnownMimeTypes.Image.VndFujixeroxEdmicsMmr,
+    KnownMimeTypes.Image.VndFujixeroxEdmicsRlc,
+    KnownMimeTypes.Image.VndXiff,
+    KnownMimeTypes.Image.VndFst,
+    KnownMimeTypes.Image.VndFastbidsheet,
+    KnownMimeTypes.Image.VndFpx,
+    KnownMimeTypes.Image.VndNetFpx,
+    KnownMimeTypes.Image.XFreehand,
+    KnownMimeTypes.Image.G3fax,
+    KnownMimeTypes.Image.Gif,
+    KnownMimeTypes.Image.XIcon,
+    KnownMimeTypes.Image.Ief,
+    KnownMimeTypes.Image.Jpeg,
+    KnownMimeTypes.Image.XCitrixJpeg,
+    KnownMimeTypes.Image.Pjpeg,
+    KnownMimeTypes.Image.VndMsModi,
+    KnownMimeTypes.Image.Ktx,
+    KnownMimeTypes.Image.XPcx,
+    KnownMimeTypes.Image.VndAdobePhotoshop,
+    KnownMimeTypes.Image.XPict,
+    KnownMimeTypes.Image.XPortableAnymap,
+    KnownMimeTypes.Image.XPortableBitmap,
+    KnownMimeTypes.Image.XPortableGraymap,
+    KnownMimeTypes.Image.Png,
+    KnownMimeTypes.Image.XCitrixPng,
+    KnownMimeTypes.Image.XPng,
+    KnownMimeTypes.Image.XPortablePixmap,
+    KnownMimeTypes.Image.SvgXml,
+    KnownMimeTypes.Image.XRgb,
+    KnownMimeTypes.Image.Tiff,
+    KnownMimeTypes.Image.VndWapWbmp,
+    KnownMimeTypes.Image.Webp,
+    KnownMimeTypes.Image.XXbitmap,
+    KnownMimeTypes.Image.XXpixmap,
+    KnownMimeTypes.Image.XXwindowdump,
+    KnownMimeTypes.Message.Rfc822,
+    KnownMimeTypes.Model.VndDwf,
+    KnownMimeTypes.Model.VndColladaXml,
+    KnownMimeTypes.Model.VndGtw,
+    KnownMimeTypes.Model.VndGdl,
+    KnownMimeTypes.Model.Iges,
+    KnownMimeTypes.Model.Mesh,
+    KnownMimeTypes.Model.Vrml,
+    KnownMimeTypes.Model.VndMts,
+    KnownMimeTypes.Model.VndVtu,
+    KnownMimeTypes.Text.XAsm,
+    KnownMimeTypes.Text.PlainBas,
+    KnownMimeTypes.Text.XC,
+    KnownMimeTypes.Text.Css,
+    KnownMimeTypes.Text.Csv,
+    KnownMimeTypes.Text.VndCurl,
+    KnownMimeTypes.Text.VndCurlDcurl,
+    KnownMimeTypes.Text.VndCurlMcurl,
+    KnownMimeTypes.Text.VndCurlScurl,
+    KnownMimeTypes.Text.VndFmiFlexstor,
+    KnownMimeTypes.Text.XFortran,
+    KnownMimeTypes.Text.VndGraphviz,
+    KnownMimeTypes.Text.Html,
+    KnownMimeTypes.Text.Calendar,
+    KnownMimeTypes.Text.VndIn3d3dml,
+    KnownMimeTypes.Text.VndIn3dSpot,
+    KnownMimeTypes.Text.VndSunJ2meAppDescriptor,
+    KnownMimeTypes.Text.XJavaSourceJava,
+    KnownMimeTypes.Text.Javascript,
+    KnownMimeTypes.Text.VndFly,
+    KnownMimeTypes.Text.N3,
+    KnownMimeTypes.Text.XPascal,
+    KnownMimeTypes.Text.PrsLinesTag,
+    KnownMimeTypes.Text.Richtext,
+    KnownMimeTypes.Text.XSetext,
+    KnownMimeTypes.Text.Sgml,
+    KnownMimeTypes.Text.TabSeparatedValues,
+    KnownMimeTypes.Text.Plain,
+    KnownMimeTypes.Text.Troff,
+    KnownMimeTypes.Text.Turtle,
+    KnownMimeTypes.Text.UriList,
+    KnownMimeTypes.Text.XUuencode,
+    KnownMimeTypes.Text.XVcalendar,
+    KnownMimeTypes.Text.XVcard,
+    KnownMimeTypes.Text.VndWapWml,
+    KnownMimeTypes.Text.VndWapWmlscript,
+    KnownMimeTypes.Text.Yaml,
+    KnownMimeTypes.Video.V3gpp,
+    KnownMimeTypes.Video.V3gpp2,
+    KnownMimeTypes.Video.XMsvideo,
+    KnownMimeTypes.Video.VndDeceHd,
+    KnownMimeTypes.Video.VndDeceMobile,
+    KnownMimeTypes.Video.VndUvvuMp4,
+    KnownMimeTypes.Video.VndDecePd,
+    KnownMimeTypes.Video.VndDeceSd,
+    KnownMimeTypes.Video.VndDeceVideo,
+    KnownMimeTypes.Video.VndFvt,
+    KnownMimeTypes.Video.XF4v,
+    KnownMimeTypes.Video.XFlv,
+    KnownMimeTypes.Video.XFli,
+    KnownMimeTypes.Video.H261,
+    KnownMimeTypes.Video.H263,
+    KnownMimeTypes.Video.H264,
+    KnownMimeTypes.Video.Jpm,
+    KnownMimeTypes.Video.Jpeg,
+    KnownMimeTypes.Video.XM4v,
+    KnownMimeTypes.Video.XMsAsf,
+    KnownMimeTypes.Video.VndMsPlayreadyMediaPyv,
+    KnownMimeTypes.Video.XMsWm,
+    KnownMimeTypes.Video.XMsWmx,
+    KnownMimeTypes.Video.XMsWmv,
+    KnownMimeTypes.Video.XMsWvx,
+    KnownMimeTypes.Video.Mj2,
+    KnownMimeTypes.Video.Mp2t,
+    KnownMimeTypes.Video.VndMpegurl,
+    KnownMimeTypes.Video.Mpeg,
+    KnownMimeTypes.Video.Mp4,
+    KnownMimeTypes.Video.Ogg,
+    KnownMimeTypes.Video.Webm,
+    KnownMimeTypes.Video.Quicktime,
+    KnownMimeTypes.Video.XSgiMovie,
+    KnownMimeTypes.Video.VndVivo,
+    KnownMimeTypes.XConference.XCooltalk,
+)

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/MimeType.kt

@@ -0,0 +1,8 @@
+package dev.inmo.micro_utils.mime_types
+
+import kotlinx.serialization.Serializable
+
+@Serializable(MimeTypeSerializer::class)
+interface MimeType {
+    val raw: String
+}

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/MimeTypeSerializer.kt

@@ -0,0 +1,24 @@
+package dev.inmo.micro_utils.mime_types
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+@Suppress("OPT_IN_USAGE")
+@Serializer(MimeType::class)
+object MimeTypeSerializer : KSerializer<MimeType> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("mimeType", PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): MimeType {
+        val mimeType = decoder.decodeString()
+        return mimeType(mimeType)
+    }
+
+    override fun serialize(encoder: Encoder, value: MimeType) {
+        encoder.encodeString(value.raw)
+    }
+}

mime_types/src/commonMain/kotlin/dev/inmo/micro_utils/mime_types/MimeTypeTools.kt

@@ -1,10 +1,5 @@
 package dev.inmo.micro_utils.mime_types
 
-import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
 private val mimesCache = mutableMapOf<String, MimeType>().also {
     knownMimeTypes.forEach { mimeType -> it[mimeType.raw] = mimeType }
 }
@@ -15,17 +10,3 @@ fun mimeType(raw: String) = mimesCache.getOrPut(raw) {
 
 internal fun parseMimeType(raw: String): MimeType = CustomMimeType(raw)
 
-@Suppress("OPT_IN_USAGE")
-@Serializer(MimeType::class)
-object MimeTypeSerializer : KSerializer<MimeType> {
-    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("mimeType", PrimitiveKind.STRING)
-
-    override fun deserialize(decoder: Decoder): MimeType {
-        val mimeType = decoder.decodeString()
-        return mimeType(mimeType)
-    }
-
-    override fun serialize(encoder: Encoder, value: MimeType) {
-        encoder.encodeString(value.raw)
-    }
-}

mppJsAndJavaProject.gradle

@@ -0,0 +1,49 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publishGradlePath"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+    }
+    js (IR) {
+        browser()
+        nodejs()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+            }
+        }
+
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation kotlin('test-js')
+                implementation kotlin('test-junit')
+            }
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

mppProjectWithSerialization.gradle

@@ -23,7 +23,7 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
-                implementation libs.kt.serialization
+                api libs.kt.serialization
             }
         }
         commonTest {
@@ -50,6 +50,8 @@ kotlin {
                 implementation libs.android.espresso
             }
         }
+
+        androidMain.dependsOn jvmMain
     }
 }
 

mppProjectWithSerializationAndCompose.gradle

@@ -23,7 +23,7 @@ kotlin {
         commonMain {
             dependencies {
                 implementation kotlin('stdlib')
-                implementation libs.kt.serialization
+                api libs.kt.serialization
                 implementation compose.runtime
             }
         }
@@ -61,6 +61,8 @@ kotlin {
                 implementation libs.android.espresso
             }
         }
+
+        androidMain.dependsOn jvmMain
     }
 }
 

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

@@ -0,0 +1,29 @@
+package dev.inmo.micro_utils.pagination.utils
+
+fun <T> Iterable<T>.optionallyReverse(reverse: Boolean): Iterable<T> = when (this) {
+    is List<T> -> optionallyReverse(reverse)
+    is Set<T> -> optionallyReverse(reverse)
+    else -> if (reverse) {
+        reversed()
+    } else {
+        this
+    }
+}
+fun <T> List<T>.optionallyReverse(reverse: Boolean): List<T> = if (reverse) {
+    reversed()
+} else {
+    this
+}
+fun <T> Set<T>.optionallyReverse(reverse: Boolean): Set<T> = if (reverse) {
+    reversed().toSet()
+} else {
+    this
+}
+
+inline fun <reified T> Array<T>.optionallyReverse(reverse: Boolean) = if (reverse) {
+    Array(size) {
+        get(lastIndex - it)
+    }
+} else {
+    this
+}

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

@@ -32,6 +32,24 @@ fun <T> List<T>.paginate(with: Pagination): PaginationResult<T> {
     )
 }
 
+fun <T> List<T>.paginate(with: Pagination, reversed: Boolean): PaginationResult<T> {
+    val actualPagination = with.optionallyReverse(
+        size,
+        reversed
+    )
+
+    val firstIndex = maxOf(actualPagination.firstIndex, 0)
+    val lastIndex = minOf(actualPagination.lastIndexExclusive, size)
+    if (firstIndex > lastIndex) {
+        return emptyPaginationResult()
+    }
+
+    return subList(firstIndex, lastIndex).optionallyReverse(reversed).createPaginationResult(
+        with,
+        size.toLong()
+    )
+}
+
 fun <T> Set<T>.paginate(with: Pagination): PaginationResult<T> {
     return this.drop(with.firstIndex).take(with.size).createPaginationResult(
         with,
@@ -39,30 +57,20 @@ fun <T> Set<T>.paginate(with: Pagination): PaginationResult<T> {
     )
 }
 
-fun <T> Iterable<T>.optionallyReverse(reverse: Boolean): Iterable<T> = when (this) {
-    is List<T> -> optionallyReverse(reverse)
-    is Set<T> -> optionallyReverse(reverse)
-    else -> if (reverse) {
-        reversed()
-    } else {
-        this
-    }
-}
-fun <T> List<T>.optionallyReverse(reverse: Boolean): List<T> = if (reverse) {
-    reversed()
-} else {
-    this
-}
-fun <T> Set<T>.optionallyReverse(reverse: Boolean): Set<T> = if (reverse) {
-    reversed().toSet()
-} else {
-    this
-}
+fun <T> Set<T>.paginate(with: Pagination, reversed: Boolean): PaginationResult<T> {
+    val actualPagination = with.optionallyReverse(
+        size,
+        reversed
+    )
 
-inline fun <reified T> Array<T>.optionallyReverse(reverse: Boolean) = if (reverse) {
-    Array(size) {
-        get(lastIndex - it)
+    val firstIndex = maxOf(actualPagination.firstIndex, 0)
+    val lastIndex = minOf(actualPagination.lastIndexExclusive, size)
+    if (firstIndex > lastIndex) {
+        return emptyPaginationResult()
     }
-} else {
-    this
+
+    return this.drop(firstIndex).take(lastIndex - firstIndex).optionallyReverse(reversed).createPaginationResult(
+        with,
+        size.toLong()
+    )
 }

publish.gradle

@@ -19,29 +19,29 @@ publishing {
             }
 
             developers {
-                
+
                     developer {
                         id = "InsanusMokrassar"
                         name = "Aleksei Ovsiannikov"
                         email = "ovsyannikov.alexey95@gmail.com"
                     }
-                
+
 
                     developer {
                         id = "000Sanya"
                         name = "Syrov Aleksandr"
                         email = "000sanya.000sanya@gmail.com"
                     }
-                
+
             }
 
             licenses {
-                
+
                     license {
                         name = "Apache Software License 2.0"
                         url = "https://github.com/InsanusMokrassar/MicroUtils/blob/master/LICENSE"
                     }
-                
+
             }
         }
         repositories {
@@ -49,35 +49,54 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/MicroUtils")
+
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
+
+                }
+            }
+            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+
+                    credentials(HttpHeaderCredentials) {
+                        name = "Authorization"
+                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                    }
+
+                    authentication {
+                        header(HttpHeaderAuthentication)
+                    }
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
+
                 }
             }
         }
     }
 }
-    
+
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-    
+
     signing {
         useGpgCmd()
-    
+
         sign publishing.publications
     }
-    
+
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

publish.kpsb

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

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CRUDCacheRepo.kt

@@ -10,12 +10,14 @@ open class ReadCRUDCacheRepo<ObjectType, IdType>(
     protected open val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
     protected open val kvCache: KVCache<IdType, ObjectType>,
     protected open val idGetter: (ObjectType) -> IdType
-) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CacheRepo {
+) : ReadCRUDRepo<ObjectType, IdType> by parentRepo, CommonCacheRepo {
     override suspend fun getById(id: IdType): ObjectType? = kvCache.get(id) ?: (parentRepo.getById(id) ?.also {
         kvCache.set(id, it)
     })
 
     override suspend fun contains(id: IdType): Boolean = kvCache.contains(id) || parentRepo.contains(id)
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <ObjectType, IdType> ReadCRUDRepo<ObjectType, IdType>.cached(
@@ -28,7 +30,7 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
     protected open val kvCache: KVCache<IdType, ObjectType>,
     protected open val scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected open val idGetter: (ObjectType) -> IdType
-) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CacheRepo {
+) : WriteCRUDRepo<ObjectType, IdType, InputValueType>, CommonCacheRepo {
     override val newObjectsFlow: Flow<ObjectType> by parentRepo::newObjectsFlow
     override val updatedObjectsFlow: Flow<ObjectType> by parentRepo::updatedObjectsFlow
     override val deletedObjectsIdsFlow: Flow<IdType> by parentRepo::deletedObjectsIdsFlow
@@ -72,6 +74,8 @@ open class WriteCRUDCacheRepo<ObjectType, IdType, InputValueType>(
 
         return created
     }
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <ObjectType, IdType, InputType> WriteCRUDRepo<ObjectType, IdType, InputType>.caching(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CacheRepo.kt

@@ -1,3 +1,5 @@
 package dev.inmo.micro_utils.repos.cache
 
-interface CacheRepo
+interface CacheRepo {
+    suspend fun invalidate()
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CommonCacheRepo.kt

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.repos.cache
+
+/**
+ * Any inheritor of this should work with next logic: try to take data from some [dev.inmo.micro_utils.repos.cache.cache.KVCache] and,
+ * if not exists, take from origin and save to the cache for future reuse
+ */
+interface CommonCacheRepo : CacheRepo

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/FallbackCacheRepo.kt

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.repos.cache
+
+/**
+ * Any inheritor of this should work with next logic: try to take data from their original repo, if successful - save data to internal
+ * [dev.inmo.micro_utils.repos.cache.cache.FullKVCache] or try to take data from that internal cache
+ */
+interface FallbackCacheRepo : CacheRepo

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValueCacheRepo.kt

@@ -10,7 +10,7 @@ import kotlinx.coroutines.flow.*
 open class ReadKeyValueCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValueRepo<Key, Value>,
     protected open val kvCache: KVCache<Key, Value>,
-) : ReadKeyValueRepo<Key,Value> by parentRepo, CacheRepo {
+) : ReadKeyValueRepo<Key,Value> by parentRepo, CommonCacheRepo {
     override suspend fun get(k: Key): Value? = kvCache.get(k) ?: parentRepo.get(k) ?.also { kvCache.set(k, it) }
     override suspend fun contains(key: Key): Boolean = kvCache.contains(key) || parentRepo.contains(key)
 
@@ -23,6 +23,8 @@ open class ReadKeyValueCacheRepo<Key,Value>(
             )
         }
     }
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> ReadKeyValueRepo<Key, Value>.cached(
@@ -33,9 +35,11 @@ open class KeyValueCacheRepo<Key,Value>(
     parentRepo: KeyValueRepo<Key, Value>,
     kvCache: KVCache<Key, Value>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CacheRepo {
+) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo, CommonCacheRepo {
     protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
     protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> KeyValueRepo<Key, Value>.cached(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValuesCacheRepo.kt

@@ -11,7 +11,7 @@ import kotlinx.coroutines.flow.*
 open class ReadKeyValuesCacheRepo<Key,Value>(
     protected open val parentRepo: ReadKeyValuesRepo<Key, Value>,
     protected open val kvCache: KVCache<Key, List<Value>>
-) : ReadKeyValuesRepo<Key,Value> by parentRepo, CacheRepo {
+) : ReadKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
         return getAll(k, reversed).paginate(
             pagination
@@ -30,6 +30,8 @@ open class ReadKeyValuesCacheRepo<Key,Value>(
         }
     })
     override suspend fun contains(k: Key): Boolean = kvCache.contains(k) || parentRepo.contains(k)
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> ReadKeyValuesRepo<Key, Value>.cached(
@@ -40,7 +42,7 @@ open class KeyValuesCacheRepo<Key,Value>(
     parentRepo: KeyValuesRepo<Key, Value>,
     kvCache: KVCache<Key, List<Value>>,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
-) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo, CacheRepo {
+) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo, CommonCacheRepo {
     protected val onNewJob = parentRepo.onNewValue.onEach { (k, v) ->
         kvCache.set(
             k,
@@ -56,6 +58,8 @@ open class KeyValuesCacheRepo<Key,Value>(
     protected val onDataClearedJob = parentRepo.onDataCleared.onEach {
         kvCache.unset(it)
     }.launchIn(scope)
+
+    override suspend fun invalidate() = kvCache.clear()
 }
 
 fun <Key, Value> KeyValuesRepo<Key, Value>.cached(

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/ActionWrapper.kt

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.repos.cache.fallback
+
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import kotlinx.coroutines.withTimeout
+
+/**
+ * Realizations should [wrap] the work with some conditions like retries on exceptions, calling timeout, etc.
+ * 
+ * @see Timeouted
+ * @see Direct
+ */
+interface ActionWrapper {
+    /**
+     * Should execute [block] to take the result [T], but may return failure in case when something went wrong.
+     * This method should never throw any [Exception]
+     */
+    suspend fun <T> wrap(block: suspend () -> T): Result<T>
+
+    /**
+     * This type of [ActionWrapper]s will use [withTimeout]([timeoutMillis]) and if original call
+     * will not return anything in that timeout just return [Result] with failure
+     */
+    class Timeouted(private val timeoutMillis: Long) : ActionWrapper {
+        override suspend fun <T> wrap(block: suspend () -> T): Result<T> = runCatchingSafely {
+            withTimeout(timeoutMillis) {
+                block()
+            }
+        }
+    }
+    /**
+     * It is passthrough variant of [ActionWrapper] which will just call incoming block with wrapping into [runCatchingSafely]
+     */
+    object Direct : ActionWrapper {
+
+        override suspend fun <T> wrap(block: suspend () -> T): Result<T> = runCatchingSafely { block() }
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheCRUDRepo.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.repos.cache.fallback.crud
+
+import dev.inmo.micro_utils.repos.CRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import kotlinx.coroutines.CoroutineScope
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheCRUDRepo<RegisteredObject, Id, InputObject>(
+    originalRepo: CRUDRepo<RegisteredObject, Id, InputObject>,
+    scope: CoroutineScope,
+    kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    actionWrapper: ActionWrapper = ActionWrapper.Direct,
+    idGetter: (RegisteredObject) -> Id
+) : AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
+    originalRepo,
+    scope,
+    kvCache,
+    recacheDelay,
+    actionWrapper,
+    idGetter
+),
+    WriteCRUDRepo<RegisteredObject, Id, InputObject> by AutoRecacheWriteCRUDRepo(originalRepo, scope, kvCache, idGetter),
+    CRUDRepo<RegisteredObject, Id, InputObject> {
+
+    constructor(
+        originalRepo: CRUDRepo<RegisteredObject, Id, InputObject>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+        idGetter: (RegisteredObject) -> Id
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheReadCRUDRepo.kt

@@ -0,0 +1,86 @@
+package dev.inmo.micro_utils.repos.cache.fallback.crud
+
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
+    protected open val originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct,
+    protected val idGetter: (RegisteredObject) -> Id
+) : ReadCRUDRepo<RegisteredObject, Id>, FallbackCacheRepo {
+    val autoUpdateJob = scope.launch {
+        while (isActive) {
+            actualizeAll()
+
+            delay(recacheDelay)
+        }
+    }
+
+    constructor(
+        originalRepo: ReadCRUDRepo<RegisteredObject, Id>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+        idGetter: (RegisteredObject) -> Id
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
+
+    protected open suspend fun actualizeAll(): Result<Unit> {
+        return runCatchingSafely {
+            kvCache.actualizeAll(originalRepo)
+        }
+    }
+
+    override suspend fun contains(id: Id): Boolean = actionWrapper.wrap {
+        originalRepo.contains(id)
+    }.getOrElse {
+        kvCache.contains(id)
+    }
+
+    override suspend fun count(): Long = actionWrapper.wrap {
+        originalRepo.count()
+    }.getOrElse {
+        kvCache.count()
+    }
+
+    override suspend fun getByPagination(
+        pagination: Pagination
+    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
+        originalRepo.getByPagination(pagination)
+    }.getOrNull() ?.also {
+        it.results.forEach {
+            kvCache.set(idGetter(it), it)
+        }
+    } ?: kvCache.values(pagination)
+
+    override suspend fun getIdsByPagination(
+        pagination: Pagination
+    ): PaginationResult<Id> = actionWrapper.wrap {
+        originalRepo.getIdsByPagination(pagination)
+    }.getOrElse { kvCache.keys(pagination) }
+
+    override suspend fun getById(id: Id): RegisteredObject? = actionWrapper.wrap {
+        originalRepo.getById(id)
+    }.getOrNull() ?.also {
+        kvCache.set(idGetter(it), it)
+    } ?: kvCache.get(id)
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/crud/AutoRecacheWriteCRUDRepo.kt

@@ -0,0 +1,65 @@
+package dev.inmo.micro_utils.repos.cache.fallback.crud
+
+import dev.inmo.micro_utils.coroutines.plus
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.repos.UpdatedValuePair
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import dev.inmo.micro_utils.repos.unset
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+
+open class AutoRecacheWriteCRUDRepo<RegisteredObject, Id, InputObject>(
+    protected val originalRepo: WriteCRUDRepo<RegisteredObject, Id, InputObject>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+    protected val idGetter: (RegisteredObject) -> Id
+) : WriteCRUDRepo<RegisteredObject, Id, InputObject>, FallbackCacheRepo {
+    override val deletedObjectsIdsFlow: Flow<Id>
+        get() = (originalRepo.deletedObjectsIdsFlow + kvCache.onValueRemoved).distinctUntilChanged()
+    override val newObjectsFlow: Flow<RegisteredObject>
+        get() = (originalRepo.newObjectsFlow + kvCache.onNewValue.map { it.second }).distinctUntilChanged()
+    override val updatedObjectsFlow: Flow<RegisteredObject>
+        get() = originalRepo.updatedObjectsFlow
+
+    private val onRemovingUpdatesListeningJob = originalRepo.deletedObjectsIdsFlow.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.unset(it)
+    }
+
+    private val onNewAndUpdatedObjectsListeningJob = merge(
+        originalRepo.newObjectsFlow,
+        originalRepo.updatedObjectsFlow,
+    ).subscribeSafelyWithoutExceptions(scope) {
+        kvCache.set(idGetter(it), it)
+    }
+
+    override suspend fun update(
+        values: List<UpdatedValuePair<Id, InputObject>>
+    ): List<RegisteredObject> = originalRepo.update(values).onEach {
+        kvCache.set(idGetter(it), it)
+    }
+
+    override suspend fun update(
+        id: Id,
+        value: InputObject
+    ): RegisteredObject? = originalRepo.update(id, value) ?.also {
+        kvCache.set(idGetter(it), it)
+    }
+
+    override suspend fun deleteById(ids: List<Id>) = originalRepo.deleteById(ids).also {
+        kvCache.unset(ids)
+    }
+
+    override suspend fun create(values: List<InputObject>): List<RegisteredObject> = originalRepo.create(values).onEach {
+        kvCache.set(idGetter(it), it)
+    }
+
+    override suspend fun invalidate() {
+        kvCache.clear()
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheKeyValueRepo.kt

@@ -0,0 +1,42 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
+
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import kotlinx.coroutines.CoroutineScope
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheKeyValueRepo<Id, RegisteredObject>(
+    override val originalRepo: KeyValueRepo<Id, RegisteredObject>,
+    scope: CoroutineScope,
+    kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    actionWrapper: ActionWrapper = ActionWrapper.Direct,
+    idGetter: (RegisteredObject) -> Id
+) : AutoRecacheReadKeyValueRepo<Id, RegisteredObject> (
+    originalRepo,
+    scope,
+    kvCache,
+    recacheDelay,
+    actionWrapper,
+    idGetter
+),
+    WriteKeyValueRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValueRepo(originalRepo, scope, kvCache),
+    KeyValueRepo<Id, RegisteredObject> {
+
+    constructor(
+        originalRepo: KeyValueRepo<Id, RegisteredObject>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+        idGetter: (RegisteredObject) -> Id
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
+
+    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
+        toUnset
+    ).also {
+        kvCache.unsetWithValues(toUnset)
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheReadKeyValueRepo.kt

@@ -0,0 +1,96 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
+
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
+    protected open val originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct,
+    protected val idGetter: (RegisteredObject) -> Id
+) : ReadKeyValueRepo<Id, RegisteredObject>, FallbackCacheRepo {
+    val autoUpdateJob = scope.launch {
+        while (isActive) {
+            actualizeAll()
+
+            delay(recacheDelay)
+        }
+    }
+
+    constructor(
+        originalRepo: ReadKeyValueRepo<Id, RegisteredObject>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+        idGetter: (RegisteredObject) -> Id
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis), idGetter)
+
+    protected open suspend fun actualizeAll(): Result<Unit> {
+        return runCatchingSafely {
+            kvCache.actualizeAll(originalRepo)
+        }
+    }
+
+    override suspend fun contains(key: Id): Boolean = actionWrapper.wrap {
+        originalRepo.contains(key)
+    }.getOrElse {
+        kvCache.contains(key)
+    }
+
+    override suspend fun count(): Long = actionWrapper.wrap {
+        originalRepo.count()
+    }.getOrElse {
+        kvCache.count()
+    }
+
+    override suspend fun get(k: Id): RegisteredObject? = actionWrapper.wrap {
+        originalRepo.get(k)
+    }.getOrNull() ?.also {
+        kvCache.set(k, it)
+    } ?: kvCache.get(k)
+
+    override suspend fun values(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
+        originalRepo.values(pagination, reversed)
+    }.getOrNull() ?.also {
+        it.results.forEach {
+            kvCache.set(idGetter(it), it)
+        }
+    } ?: kvCache.values(pagination, reversed)
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Id> = actionWrapper.wrap {
+        originalRepo.keys(pagination, reversed)
+    }.getOrElse { kvCache.keys(pagination, reversed) }
+
+    override suspend fun keys(
+        v: RegisteredObject,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Id> = actionWrapper.wrap {
+        originalRepo.keys(v, pagination, reversed)
+    }.getOrElse { kvCache.keys(v, pagination, reversed) }
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalue/AutoRecacheWriteKeyValueRepo.kt

@@ -0,0 +1,54 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalue
+
+import dev.inmo.micro_utils.coroutines.plus
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import dev.inmo.micro_utils.repos.unset
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+
+open class AutoRecacheWriteKeyValueRepo<Id, RegisteredObject>(
+    protected val originalRepo: WriteKeyValueRepo<Id, RegisteredObject>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, RegisteredObject> = FullKVCache()
+) : WriteKeyValueRepo<Id, RegisteredObject>, FallbackCacheRepo {
+    override val onValueRemoved: Flow<Id>
+        get() = (originalRepo.onValueRemoved + kvCache.onValueRemoved).distinctUntilChanged()
+
+    override val onNewValue: Flow<Pair<Id, RegisteredObject>>
+        get() = (originalRepo.onNewValue + kvCache.onNewValue).distinctUntilChanged()
+
+    private val onRemovingUpdatesListeningJob = originalRepo.onValueRemoved.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.unset(it)
+    }
+
+    private val onNewAndUpdatedObjectsListeningJob = originalRepo.onNewValue.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.set(it.first, it.second)
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<RegisteredObject>) = originalRepo.unsetWithValues(
+        toUnset
+    ).also {
+        kvCache.unsetWithValues(toUnset)
+    }
+
+    override suspend fun unset(toUnset: List<Id>) = originalRepo.unset(
+        toUnset
+    ).also {
+        kvCache.unset(toUnset)
+    }
+
+    override suspend fun set(toSet: Map<Id, RegisteredObject>) = originalRepo.set(
+        toSet
+    ).also {
+        kvCache.set(toSet)
+    }
+
+    override suspend fun invalidate() {
+        kvCache.clear()
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheKeyValueRepo.kt

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
+
+import dev.inmo.micro_utils.repos.KeyValuesRepo
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import kotlinx.coroutines.CoroutineScope
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheKeyValuesRepo<Id, RegisteredObject>(
+    override val originalRepo: KeyValuesRepo<Id, RegisteredObject>,
+    scope: CoroutineScope,
+    kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
+    recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    actionWrapper: ActionWrapper = ActionWrapper.Direct
+) : AutoRecacheReadKeyValuesRepo<Id, RegisteredObject> (
+    originalRepo,
+    scope,
+    kvCache,
+    recacheDelay,
+    actionWrapper
+),
+    WriteKeyValuesRepo<Id, RegisteredObject> by AutoRecacheWriteKeyValuesRepo(originalRepo, scope, kvCache),
+    KeyValuesRepo<Id, RegisteredObject> {
+
+    constructor(
+        originalRepo: KeyValuesRepo<Id, RegisteredObject>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis))
+
+    override suspend fun clearWithValue(v: RegisteredObject) {
+        super.clearWithValue(v)
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheReadKeyValuesRepo.kt

@@ -0,0 +1,145 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
+
+import dev.inmo.micro_utils.coroutines.runCatchingSafely
+import dev.inmo.micro_utils.pagination.Pagination
+import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.changeResultsUnchecked
+import dev.inmo.micro_utils.pagination.createPaginationResult
+import dev.inmo.micro_utils.pagination.emptyPaginationResult
+import dev.inmo.micro_utils.pagination.firstIndex
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
+import dev.inmo.micro_utils.pagination.utils.optionallyReverse
+import dev.inmo.micro_utils.pagination.utils.paginate
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.fallback.ActionWrapper
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.seconds
+
+open class AutoRecacheReadKeyValuesRepo<Id, RegisteredObject>(
+    protected open val originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
+    protected val recacheDelay: Long = 60.seconds.inWholeMilliseconds,
+    protected val actionWrapper: ActionWrapper = ActionWrapper.Direct
+) : ReadKeyValuesRepo<Id, RegisteredObject>, FallbackCacheRepo {
+    val autoUpdateJob = scope.launch {
+        while (isActive) {
+            actualizeAll()
+
+            delay(recacheDelay)
+        }
+    }
+
+    constructor(
+        originalRepo: ReadKeyValuesRepo<Id, RegisteredObject>,
+        scope: CoroutineScope,
+        originalCallTimeoutMillis: Long,
+        kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache(),
+        recacheDelay: Long = 60.seconds.inWholeMilliseconds
+    ) : this(originalRepo, scope, kvCache, recacheDelay, ActionWrapper.Timeouted(originalCallTimeoutMillis))
+
+    protected open suspend fun actualizeAll(): Result<Unit> {
+        return runCatchingSafely {
+            kvCache.actualizeAll(originalRepo)
+        }
+    }
+
+    override suspend fun contains(k: Id): Boolean = actionWrapper.wrap {
+        originalRepo.contains(k)
+    }.getOrElse {
+        kvCache.contains(k)
+    }
+
+    override suspend fun count(): Long = actionWrapper.wrap {
+        originalRepo.count()
+    }.getOrElse {
+        kvCache.count()
+    }
+
+    override suspend fun keys(
+        v: RegisteredObject,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Id> = actionWrapper.wrap {
+        originalRepo.keys(v, pagination, reversed)
+    }.getOrElse {
+        val results = mutableListOf<Id>()
+
+        val toSkip = pagination.firstIndex
+        var count = 0
+
+        doForAllWithNextPaging {
+            kvCache.keys(pagination, reversed).also {
+                it.results.forEach {
+                    if (kvCache.get(it) ?.contains(v) == true) {
+                        count++
+                        if (count < toSkip || results.size >= pagination.size) {
+                            return@forEach
+                        } else {
+                            results.add(it)
+                        }
+                    }
+                }
+            }
+        }
+
+        return@getOrElse results.createPaginationResult(
+            pagination,
+            count.toLong()
+        )
+    }
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Id> = actionWrapper.wrap {
+        originalRepo.keys(pagination, reversed)
+    }.getOrElse { kvCache.keys(pagination, reversed) }
+
+    override suspend fun get(
+        k: Id,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<RegisteredObject> = actionWrapper.wrap {
+        originalRepo.get(k, pagination, reversed)
+    }.getOrNull() ?.also {
+        it.results.forEach {
+            kvCache.set(k, ((kvCache.get(k) ?: return@also) + it).distinct())
+        }
+    } ?: kvCache.get(k) ?.run {
+        paginate(pagination.optionallyReverse(size, reversed)).let {
+            if (reversed) {
+                it.changeResultsUnchecked(
+                    it.results.reversed()
+                )
+            } else {
+                it
+            }
+        }
+    } ?: emptyPaginationResult()
+
+    override suspend fun count(k: Id): Long = actionWrapper.wrap {
+        originalRepo.count(k)
+    }.getOrElse {
+        kvCache.get(k) ?.size ?.toLong() ?: 0L
+    }
+
+    override suspend fun contains(k: Id, v: RegisteredObject): Boolean {
+        return (actionWrapper.wrap {
+            originalRepo.contains(k, v)
+        }.getOrNull() ?.also {
+            kvCache.set(k, ((kvCache.get(k) ?: return@also) + v).distinct())
+        }) ?: (kvCache.get(k) ?.contains(v) == true)
+    }
+
+    override suspend fun invalidate() {
+        actualizeAll()
+    }
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/fallback/keyvalues/AutoRecacheWriteKeyValuesRepo.kt

@@ -0,0 +1,86 @@
+package dev.inmo.micro_utils.repos.cache.fallback.keyvalues
+
+import dev.inmo.micro_utils.coroutines.plus
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.pagination.FirstPagePagination
+import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
+import dev.inmo.micro_utils.repos.cache.cache.FullKVCache
+import dev.inmo.micro_utils.repos.cache.FallbackCacheRepo
+import dev.inmo.micro_utils.repos.set
+import dev.inmo.micro_utils.repos.unset
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+
+open class AutoRecacheWriteKeyValuesRepo<Id, RegisteredObject>(
+    protected val originalRepo: WriteKeyValuesRepo<Id, RegisteredObject>,
+    protected val scope: CoroutineScope,
+    protected val kvCache: FullKVCache<Id, List<RegisteredObject>> = FullKVCache()
+) : WriteKeyValuesRepo<Id, RegisteredObject>, FallbackCacheRepo {
+    override val onValueRemoved: Flow<Pair<Id, RegisteredObject>>
+        get() = originalRepo.onValueRemoved
+
+    override val onNewValue: Flow<Pair<Id, RegisteredObject>>
+        get() = originalRepo.onNewValue
+    override val onDataCleared: Flow<Id>
+        get() = (originalRepo.onDataCleared + kvCache.onValueRemoved).distinctUntilChanged()
+
+    private val onDataClearedListeningJob = originalRepo.onDataCleared.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.unset(it)
+    }
+
+    private val onRemovingUpdatesListeningJob = originalRepo.onValueRemoved.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.set(
+            it.first,
+            (kvCache.get(
+                it.first
+            ) ?: return@subscribeSafelyWithoutExceptions) - it.second
+        )
+    }
+
+    private val onNewAndUpdatedObjectsListeningJob = originalRepo.onNewValue.subscribeSafelyWithoutExceptions(scope) {
+        kvCache.set(
+            it.first,
+            (kvCache.get(
+                it.first
+            ) ?: return@subscribeSafelyWithoutExceptions) + it.second
+        )
+    }
+
+    override suspend fun clearWithValue(v: RegisteredObject) {
+        originalRepo.clearWithValue(v)
+        doForAllWithNextPaging(FirstPagePagination(kvCache.count().takeIf { it < Int.MAX_VALUE } ?.toInt() ?: Int.MAX_VALUE)) {
+            kvCache.keys(it).also {
+                it.results.forEach { id ->
+                    kvCache.get(id) ?.takeIf { it.contains(v) } ?.let {
+                        kvCache.unset(id)
+                    }
+                }
+            }
+        }
+    }
+
+    override suspend fun clear(k: Id) {
+        originalRepo.clear(k)
+        kvCache.unset(k)
+    }
+
+    override suspend fun remove(toRemove: Map<Id, List<RegisteredObject>>) {
+        originalRepo.remove(toRemove)
+        toRemove.forEach { (k, v) ->
+            kvCache.set(k, (kvCache.get(k) ?: return@forEach) - v)
+        }
+    }
+
+    override suspend fun add(toAdd: Map<Id, List<RegisteredObject>>) {
+        originalRepo.add(toAdd)
+        toAdd.forEach { (k, v) ->
+            kvCache.set(k, (kvCache.get(k) ?: return@forEach) + v)
+        }
+    }
+
+    override suspend fun invalidate() {
+        kvCache.clear()
+    }
+}