update ktor

0.17.7

CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 0.17.8
+
+* `Versions`:
+    * `Ktor`: `2.2.4` -> `2.3.0`
+
+## 0.17.7
+
+* `Versions`:
+    * `Android CoreKtx`: `1.9.0` -> `1.10.0`
+* `Startup`:
+    * Add support of `linuxX64` and `mingwX64` platforms
+
+## 0.17.6
+
+* `Versions`:
+    * `Kotlin`: `1.8.10` -> `1.8.20`
+    * `KSLog`: `1.0.0` -> `1.1.1`
+    * `Compose`: `1.3.1` -> `1.4.0`
+    * `Koin`: `3.3.2` -> `3.4.0`
+    * `RecyclerView`: `1.2.1` -> `1.3.0`
+    * `Fragment`: `1.5.5` -> `1.5.6`
+* Experimentally (`!!!`) add `linuxX64` and `mingwX64` targets
+
+## 0.17.5
+
+* `Common`:
+    * Conversations of number primitives with bounds care
+* `Repos`:
+    * `Common`:
+        * By default, `getAll` for repos will take all the size of repo as page size
+        * New extension for all built-in repos `maxPagePagination`
+    * All the repos got `getAll` functions
+
+## 0.17.4
+
+* `Serialization`:
+    * `Mapper`:
+        * Module inited
+* `Versions`:
+    * `Compose`: `1.3.1-rc02` -> `1.3.1`
+
+## 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`:

build.gradle

@@ -23,6 +23,7 @@ allprojects {
         mavenCentral()
         google()
         maven { url "https://maven.pkg.jetbrains.space/public/p/compose/dev" }
+        maven { url "https://git.inmo.dev/api/packages/InsanusMokrassar/maven" }
     }
 
     // temporal crutch until legacy tests will be stabled or legacy target will be removed

common/build.gradle

@@ -20,5 +20,16 @@ kotlin {
             }
             dependsOn jvmMain
         }
+
+        linuxX64Main {
+            dependencies {
+                api libs.okio
+            }
+        }
+        mingwX64Main {
+            dependencies {
+                api libs.okio
+            }
+        }
     }
 }

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

@@ -34,7 +34,11 @@ data class Diff<T> internal constructor(
      */
     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>?>>,
@@ -43,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 {
@@ -104,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
@@ -132,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>>
@@ -143,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)
 
 /**
@@ -187,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/PrimitivesConversations.kt

@@ -0,0 +1,28 @@
+package dev.inmo.micro_utils.common
+
+/**
+ * Convert [this] [Long] to [Int] with bounds of [Int.MIN_VALUE] and [Int.MAX_VALUE]
+ */
+fun Long.toCoercedInt(): Int = coerceIn(Int.MIN_VALUE.toLong(), Int.MAX_VALUE.toLong()).toInt()
+/**
+ * Convert [this] [Long] to [Short] with bounds of [Short.MIN_VALUE] and [Short.MAX_VALUE]
+ */
+fun Long.toCoercedShort(): Short = coerceIn(Short.MIN_VALUE.toLong(), Short.MAX_VALUE.toLong()).toShort()
+/**
+ * Convert [this] [Long] to [Byte] with bounds of [Byte.MIN_VALUE] and [Byte.MAX_VALUE]
+ */
+fun Long.toCoercedByte(): Byte = coerceIn(Byte.MIN_VALUE.toLong(), Byte.MAX_VALUE.toLong()).toByte()
+
+/**
+ * Convert [this] [Int] to [Short] with bounds of [Short.MIN_VALUE] and [Short.MAX_VALUE]
+ */
+fun Int.toCoercedShort(): Short = coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt()).toShort()
+/**
+ * Convert [this] [Int] to [Byte] with bounds of [Byte.MIN_VALUE] and [Byte.MAX_VALUE]
+ */
+fun Int.toCoercedByte(): Byte = coerceIn(Byte.MIN_VALUE.toInt(), Byte.MAX_VALUE.toInt()).toByte()
+
+/**
+ * Convert [this] [Short] to [Byte] with bounds of [Byte.MIN_VALUE] and [Byte.MAX_VALUE]
+ */
+fun Short.toCoercedByte(): Byte = coerceIn(Byte.MIN_VALUE.toShort(), Byte.MAX_VALUE.toShort()).toByte()

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/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();

common/src/linuxX64Main/kotlin/ActualMPPFile.kt

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

common/src/linuxX64Main/kotlin/fixed.kt

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

common/src/mingwX64Main/kotlin/ActualMPPFile.kt

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

common/src/mingwX64Main/kotlin/fixed.kt

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

coroutines/src/jsMain/kotlin/dev.inmo.micro_utils.coroutines/ImagePreloading.kt

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Job
+import org.w3c.dom.Image
+
+suspend fun preloadImage(src: String): Image {
+    val image = Image()
+    image.src = src
+
+    val job = Job()
+
+    image.addEventListener("load", {
+        runCatching { job.complete() }
+    })
+
+    runCatchingSafely {
+        job.join()
+    }.onFailure {
+        if (it is CancellationException) {
+            image.src = ""
+        }
+    }.getOrThrow()
+
+    return image
+}

crypto/build.gradle

@@ -11,6 +11,7 @@ kotlin {
         commonMain {
             dependencies {
                 api project(":micro_utils.common")
+                api libs.krypto
             }
         }
         jsMain {

crypto/src/commonMain/kotlin/dev/inmo/micro_utils/crypto/MD5.kt

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.crypto
 
+import com.soywiz.krypto.md5
+
 typealias MD5 = String
 
-expect fun SourceBytes.md5(): MD5
-fun SourceString.md5(): MD5 = encodeToByteArray().md5()
+fun SourceBytes.md5(): MD5 = md5().hexLower
+fun SourceString.md5(): MD5 = encodeToByteArray().md5().hexLower

crypto/src/jsMain/kotlin/dev/inmo/micro_utils/crypto/MD5Realization.kt

@@ -1,6 +0,0 @@
-package dev.inmo.micro_utils.crypto
-
-/**
- * @suppress
- */
-actual fun SourceBytes.md5(): MD5 = CryptoJS.MD5(decodeToString())

crypto/src/jvmMain/kotlin/dev/inmo/micro_utils/crypto/MD5Realization.kt

@@ -1,12 +0,0 @@
-package dev.inmo.micro_utils.crypto
-
-import java.math.BigInteger
-import java.security.MessageDigest
-
-/**
- * @suppress
- */
-actual fun SourceBytes.md5(): MD5 = BigInteger(
-    1,
-    MessageDigest.getInstance("MD5").digest(this)
-).toString(16)

extensions.gradle

@@ -23,7 +23,7 @@ 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"
+        mppJvmJsLinuxMingwProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJvmJsLinuxMingwProject.gradle"
         mppAndroidProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppAndroidProject.gradle"
 
         defaultAndroidSettingsPresetPath = "${rootProject.projectDir.absolutePath}/defaultAndroidSettings.gradle"

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.17.2
-android_code_version=184
+version=0.17.8
+android_code_version=190

gradle/libs.versions.toml

@@ -1,34 +1,36 @@
 [versions]
 
-kt = "1.8.10"
+kt = "1.8.20"
 kt-serialization = "1.5.0"
 kt-coroutines = "1.6.4"
 
-kslog = "1.0.0"
+kslog = "1.1.1"
 
-jb-compose = "1.3.1-rc01"
+jb-compose = "1.4.0"
 jb-exposed = "0.41.1"
-jb-dokka = "1.7.20"
+jb-dokka = "1.8.10"
 
-klock = "3.4.0"
+korlibs = "3.4.0"
 uuid = "0.7.0"
 
-ktor = "2.2.4"
+ktor = "2.3.0"
 
 gh-release = "2.4.1"
 
-koin = "3.3.2"
+koin = "3.4.0"
 
-ksp = "1.8.10-1.0.9"
-kotlin-poet = "1.12.0"
+okio = "3.3.0"
+
+ksp = "1.8.20-1.0.11"
+kotlin-poet = "1.13.0"
 
 android-gradle = "7.3.1"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.9.0"
-android-recyclerView = "1.2.1"
+android-coreKtx = "1.10.0"
+android-recyclerView = "1.3.0"
 android-appCompat = "1.6.1"
-android-fragment = "1.5.5"
+android-fragment = "1.5.6"
 android-espresso = "3.5.1"
 android-test = "1.1.5"
 
@@ -67,7 +69,8 @@ ktor-server-content-negotiation = { module = "io.ktor:ktor-server-content-negoti
 
 kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
 
-klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "klock" }
+klock = { module = "com.soywiz.korlibs.klock:klock", version.ref = "korlibs" }
+krypto = { module = "com.soywiz.korlibs.krypto:krypto", version.ref = "korlibs" }
 uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
 koin = { module = "io.insert-koin:koin-core", version.ref = "koin" }
 
@@ -91,6 +94,8 @@ kt-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref
 kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
 ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
 
+okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
+
 # Buildscript
 
 buildscript-kt-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kt" }

ktor/client/build.gradle

@@ -18,5 +18,17 @@ kotlin {
         androidMain {
             dependsOn jvmMain
         }
+
+        linuxX64Main {
+            dependencies {
+                api internalProject("micro_utils.mime_types")
+            }
+        }
+
+        mingwX64Main {
+            dependencies {
+                api internalProject("micro_utils.mime_types")
+            }
+        }
     }
 }

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

@@ -1,6 +1,10 @@
 package dev.inmo.micro_utils.ktor.client
 
 import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filesize
+import dev.inmo.micro_utils.ktor.common.input
 import io.ktor.client.request.forms.InputProvider
 
-expect suspend fun MPPFile.inputProvider(): InputProvider
+fun MPPFile.inputProvider(): InputProvider = InputProvider(filesize) {
+    input()
+}

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

@@ -1,11 +0,0 @@
-package dev.inmo.micro_utils.ktor.client
-
-import dev.inmo.micro_utils.common.*
-import io.ktor.client.request.forms.InputProvider
-import io.ktor.utils.io.core.ByteReadPacket
-
-actual suspend fun MPPFile.inputProvider(): InputProvider = bytes().let {
-    InputProvider(it.size.toLong()) {
-        ByteReadPacket(it)
-    }
-}

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

@@ -7,5 +7,3 @@ import io.ktor.utils.io.streams.asInput
 fun MPPFile.inputProviderSync(): InputProvider = InputProvider(length()) {
     inputStream().asInput()
 }
-
-actual suspend fun MPPFile.inputProvider(): InputProvider = inputProviderSync()

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

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filename
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+
+internal val MPPFile.mimeType: String
+    get() = getMimeTypeOrAny(filename.extension).raw
+
+actual suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: OnUploadCallback
+): TemporalFileId {
+    val inputProvider = file.inputProvider()
+    val fileId = submitFormWithBinaryData(
+        fullTempUploadDraftPath,
+        formData = formData {
+            append(
+                "data",
+                inputProvider,
+                Headers.build {
+                    append(HttpHeaders.ContentType, file.mimeType)
+                    append(HttpHeaders.ContentDisposition, "filename=\"${file.filename.string}\"")
+                }
+            )
+        }
+    ) {
+        onUpload(onUpload)
+    }.bodyAsText()
+    return TemporalFileId(fileId)
+}

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

@@ -0,0 +1,107 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.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
+
+/**
+ * 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 MPPFile || it is UniUploadFileInfo }
+
+    val formData = formData {
+        for (k in data.keys) {
+            val v = data[k] ?: continue
+            when (v) {
+                is MPPFile -> append(
+                    k,
+                    v.inputProvider(),
+                    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/client/src/mingwX64Main/kotlin/ActualTemporalUpload.kt

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.filename
+import dev.inmo.micro_utils.ktor.common.TemporalFileId
+import dev.inmo.micro_utils.mime_types.getMimeTypeOrAny
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.onUpload
+import io.ktor.client.request.forms.formData
+import io.ktor.client.request.forms.submitFormWithBinaryData
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.Headers
+import io.ktor.http.HttpHeaders
+
+internal val MPPFile.mimeType: String
+    get() = getMimeTypeOrAny(filename.extension).raw
+
+actual suspend fun HttpClient.tempUpload(
+    fullTempUploadDraftPath: String,
+    file: MPPFile,
+    onUpload: OnUploadCallback
+): TemporalFileId {
+    val inputProvider = file.inputProvider()
+    val fileId = submitFormWithBinaryData(
+        fullTempUploadDraftPath,
+        formData = formData {
+            append(
+                "data",
+                inputProvider,
+                Headers.build {
+                    append(HttpHeaders.ContentType, file.mimeType)
+                    append(HttpHeaders.ContentDisposition, "filename=\"${file.filename.string}\"")
+                }
+            )
+        }
+    ) {
+        onUpload(onUpload)
+    }.bodyAsText()
+    return TemporalFileId(fileId)
+}

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

@@ -0,0 +1,107 @@
+package dev.inmo.micro_utils.ktor.client
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.Progress
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.mergeHeaders
+import io.ktor.client.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
+
+/**
+ * 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 MPPFile || it is UniUploadFileInfo }
+
+    val formData = formData {
+        for (k in data.keys) {
+            val v = data[k] ?: continue
+            when (v) {
+                is MPPFile -> append(
+                    k,
+                    v.inputProvider(),
+                    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/src/linuxX64Main/kotlin/ActualMPPFileInput.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.bytesAllocatorSync
+import io.ktor.utils.io.core.ByteReadPacket
+import io.ktor.utils.io.core.Input
+
+actual fun MPPFile.input(): Input {
+    return ByteReadPacket(bytesAllocatorSync())
+}
+

ktor/common/src/mingwX64Main/kotlin/ActualMPPFileInput.kt

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.ktor.common
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.common.bytesAllocatorSync
+import io.ktor.utils.io.core.ByteReadPacket
+import io.ktor.utils.io.core.Input
+
+actual fun MPPFile.input(): Input {
+    return ByteReadPacket(bytesAllocatorSync())
+}

mime_types/mimes_generator/mime_generator.py

@@ -1,3 +1,5 @@
+import math
+
 import requests
 from bs4 import BeautifulSoup
 import pandas as pd
@@ -17,33 +19,45 @@ def fix_name(category, raw_name):
         result += out1
     return result
 
+def remove_prefix(text, prefix):
+    if text.startswith(prefix):
+        return text[len(prefix):]
+    return text  # or whatever
+
+def extensionPreparationFun(extension):
+    return "\"%s\"" % (remove_prefix(extension, "."))
+
 # https://www.freeformatter.com/mime-types-list.html
 if __name__ == '__main__':
-    df = pd.read_html(open('table.html', 'r'))
+    df = pd.read_html(open('local.table.html', 'r'))
     mimes = []
     for row in df[0].drop_duplicates(subset=['MIME Type / Internet Media Type'], keep='first').iterrows():
         mime = row[1][1]
+        extensions = list()
+        if isinstance(row[1][2], str):
+            extensions = list(map(extensionPreparationFun, row[1][2].split(", ")))
         mime_category = mime.split('/', 1)[0]
         mime_name = mime.split('/', 1)[1]
-        mimes.append({
-            'mime_category': mime_category,
-            'mime_name': mime_name,
-        })
+        mimes.append([
+            mime_category,
+            mime_name,
+            extensions
+        ])
 
     # codegen
 
-    mimes.sort(key=lambda x: x['mime_category'])
-    grouped = itertools.groupby(mimes, lambda x: x['mime_category'])
+    mimes.sort(key=lambda x: x[0])
+    grouped = itertools.groupby(mimes, lambda x: x[0])
     code = ''
     code2 = 'internal val knownMimeTypes: Set<MimeType> = setOf(\n'
     code2 += '    KnownMimeTypes.Any,\n'
     for key, group in grouped:
         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)\nsealed class %s(raw: String, extensions: Array<String> = emptyArray()) : MimeType, KnownMimeTypes(raw, extensions) {\n' % group_name
         code += '    @Serializable(MimeTypeSerializer::class)\n    object Any: %s ("%s/*")\n' % (group_name, key)
         for mime in group:
-            name = fix_name(mime['mime_category'], mime['mime_name'])
-            code += '    @Serializable(MimeTypeSerializer::class)\n    object %s: %s ("%s/%s")\n' % (name, group_name, mime['mime_category'], mime['mime_name'])
+            name = fix_name(mime[0], mime[1])
+            code += '    @Serializable(MimeTypeSerializer::class)\n    object %s: %s ("%s/%s", arrayOf(%s))\n' % (name, group_name, mime[0], mime[1], ", ".join(mime[2]))
             code2 += '    KnownMimeTypes.%s.%s,\n' % (group_name, name)
         code += '}\n\n'
     code2 += ')\n'

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

@@ -0,0 +1,24 @@
+package dev.inmo.micro_utils.mime_types
+
+val mimeTypesByExtensions: Map<String, Array<MimeType>> by lazy {
+    val extensionsMap = mutableMapOf<String, MutableList<MimeType>>()
+
+    knownMimeTypes.forEach { mimeType ->
+        mimeType.extensions.forEach {
+            extensionsMap.getOrPut(it) { mutableListOf() }.add(mimeType)
+        }
+    }
+
+    extensionsMap.mapValues {
+        it.value.toTypedArray()
+    }
+}
+
+inline fun getMimeType(
+    stringWithExtension: String,
+    selector: (Array<MimeType>) -> MimeType? = { it.firstOrNull() }
+) = mimeTypesByExtensions[stringWithExtension.takeLastWhile { it != '.' }] ?.takeIf { it.isNotEmpty() } ?.let(selector)
+inline fun getMimeTypeOrAny(
+    stringWithExtension: String,
+    selector: (Array<MimeType>) -> MimeType? = { it.firstOrNull() }
+) = getMimeType(stringWithExtension, selector) ?: KnownMimeTypes.Any

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

@@ -5,4 +5,6 @@ import kotlinx.serialization.Serializable
 @Serializable(MimeTypeSerializer::class)
 interface MimeType {
     val raw: String
+    val extensions: Array<String>
+        get() = emptyArray()
 }

mppJvmJsLinuxMingwProject.gradle

@@ -15,6 +15,8 @@ kotlin {
         browser()
         nodejs()
     }
+    linuxX64()
+    mingwX64()
 
     sourceSets {
         commonMain {

mppProjectWithSerialization.gradle

@@ -18,6 +18,8 @@ kotlin {
     android {
         publishAllLibraryVariants()
     }
+    linuxX64()
+    mingwX64()
 
     sourceSets {
         commonMain {
@@ -50,6 +52,16 @@ kotlin {
                 implementation libs.android.espresso
             }
         }
+        mingwX64Test {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+        linuxX64Test {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
 
         androidMain.dependsOn jvmMain
     }

renovate.json

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

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

@@ -2,6 +2,7 @@ package dev.inmo.micro_utils.repos.cache
 
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.cache.cache.KVCache
+import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
@@ -15,6 +16,12 @@ open class ReadCRUDCacheRepo<ObjectType, IdType>(
         kvCache.set(id, it)
     })
 
+    override suspend fun getAll(): Map<IdType, ObjectType> {
+        return kvCache.getAll().takeIf { it.size.toLong() == count() } ?: parentRepo.getAll().also {
+            kvCache.actualizeAll(true) { it }
+        }
+    }
+
     override suspend fun contains(id: IdType): Boolean = kvCache.contains(id) || parentRepo.contains(id)
 
     override suspend fun invalidate() = kvCache.clear()

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

@@ -24,6 +24,12 @@ open class ReadKeyValueCacheRepo<Key,Value>(
         }
     }
 
+    override suspend fun getAll(): Map<Key, Value> = kvCache.getAll().takeIf {
+        it.size.toLong() == count()
+    } ?: parentRepo.getAll().also {
+        kvCache.set(it)
+    }
+
     override suspend fun invalidate() = kvCache.clear()
 }
 

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

@@ -52,6 +52,14 @@ open class AutoRecacheReadCRUDRepo<RegisteredObject, Id>(
         kvCache.contains(id)
     }
 
+    override suspend fun getAll(): Map<Id, RegisteredObject> = actionWrapper.wrap {
+        originalRepo.getAll()
+    }.onSuccess {
+        kvCache.actualizeAll(clear = true) { it }
+    }.getOrElse {
+        kvCache.getAll()
+    }
+
     override suspend fun count(): Long = actionWrapper.wrap {
         originalRepo.count()
     }.getOrElse {

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

@@ -52,6 +52,14 @@ open class AutoRecacheReadKeyValueRepo<Id, RegisteredObject>(
         kvCache.contains(key)
     }
 
+    override suspend fun getAll(): Map<Id, RegisteredObject> = actionWrapper.wrap {
+        originalRepo.getAll()
+    }.onSuccess {
+        kvCache.actualizeAll(clear = true) { it }
+    }.getOrElse {
+        kvCache.getAll()
+    }
+
     override suspend fun count(): Long = actionWrapper.wrap {
         originalRepo.count()
     }.getOrElse {

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

@@ -58,6 +58,12 @@ open class FullReadCRUDCacheRepo<ObjectType, IdType>(
         { if (it) parentRepo.getById(id) ?.let { set(id, it) } }
     )
 
+    override suspend fun getAll(): Map<IdType, ObjectType> = doOrTakeAndActualize(
+        { getAll().takeIf { it.isNotEmpty() }.optionalOrAbsentIfNull },
+        { getAll() },
+        { kvCache.actualizeAll(clear = true) { it } }
+    )
+
     override suspend fun getById(id: IdType): ObjectType? = doOrTakeAndActualize(
         { get(id) ?.optional ?: Optional.absent() },
         { getById(id) },

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

@@ -9,7 +9,6 @@ import dev.inmo.micro_utils.repos.cache.util.actualizeAll
 import dev.inmo.micro_utils.repos.pagination.getAll
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.*
 
 open class FullReadKeyValueCacheRepo<Key,Value>(
@@ -59,6 +58,12 @@ open class FullReadKeyValueCacheRepo<Key,Value>(
         { if (it) parentRepo.get(key) ?.also { kvCache.set(key, it) } }
     )
 
+    override suspend fun getAll(): Map<Key, Value> = doOrTakeAndActualize(
+        { getAll().takeIf { it.isNotEmpty() }.optionalOrAbsentIfNull },
+        { getAll() },
+        { kvCache.actualizeAll(clear = true) { it } }
+    )
+
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = doOrTakeAndActualize(
         { keys(pagination, reversed).takeIf { it.results.isNotEmpty() }.optionalOrAbsentIfNull },
         { keys(pagination, reversed) },

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/util/ActualizeAll.kt

@@ -28,7 +28,7 @@ suspend inline fun <K, V> KVCache<K, V>.actualizeAll(
     clear: Boolean = true,
 ) {
     actualizeAll(clear) {
-        repo.getAll { keys(it) }.toMap()
+        repo.getAll()
     }
 }
 
@@ -37,7 +37,7 @@ suspend inline fun <K, V> KVCache<K, List<V>>.actualizeAll(
     clear: Boolean = true,
 ) {
     actualizeAll(clear) {
-        repo.getAll { keys(it) }.toMap()
+        repo.getAll()
     }
 }
 
@@ -46,8 +46,6 @@ suspend inline fun <K, V> KVCache<K, V>.actualizeAll(
     clear: Boolean = true,
 ) {
     actualizeAll(clear) {
-        repo.getAllByWithNextPaging {
-            getIdsByPagination(it)
-        }.mapNotNull { it to (repo.getById(it) ?: return@mapNotNull null) }.toMap()
+        repo.getAll()
     }
 }

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

@@ -2,8 +2,10 @@ package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
+import dev.inmo.micro_utils.pagination.utils.getAllByWithNextPaging
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.pagination.utils.paginate
+import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import kotlinx.coroutines.flow.Flow
 
 /**
@@ -51,6 +53,16 @@ interface ReadKeyValueRepo<Key, Value> : Repo {
      */
     suspend fun contains(key: Key): Boolean
 
+    suspend fun getAll(): Map<Key, Value> = getAllByWithNextPaging(maxPagePagination()) {
+        keys(it).let {
+            it.changeResultsUnchecked(
+                it.results.mapNotNull {
+                    it to (get(it) ?: return@mapNotNull null)
+                }
+            )
+        }
+    }.toMap()
+
     /**
      * @return count of all collection objects
      */

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

@@ -2,6 +2,9 @@ package dev.inmo.micro_utils.repos
 
 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.utils.getAllWithCurrentPaging
+import dev.inmo.micro_utils.repos.pagination.maxPagePagination
 import kotlinx.coroutines.flow.Flow
 
 interface ReadCRUDRepo<ObjectType, IdType> : Repo {
@@ -9,6 +12,14 @@ interface ReadCRUDRepo<ObjectType, IdType> : Repo {
     suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType>
     suspend fun getById(id: IdType): ObjectType?
     suspend fun contains(id: IdType): Boolean
+    suspend fun getAll(): Map<IdType, ObjectType> = getAllWithCurrentPaging(maxPagePagination()) {
+        getIdsByPagination(it).let {
+            it.changeResultsUnchecked(
+                it.results.mapNotNull { it to (getById(it) ?: return@mapNotNull null) }
+            )
+        }
+    }.toMap()
+
     suspend fun count(): Long
 }
 typealias ReadStandardCRUDRepo<ObjectType, IdType> = ReadCRUDRepo<ObjectType, IdType>

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/CRUDMappers.kt

@@ -32,6 +32,10 @@ open class MapperReadCRUDRepo<FromId, FromRegistered, ToId, ToRegistered>(
 
     override suspend fun contains(id: FromId): Boolean = to.contains(id.toOutKey())
 
+    override suspend fun getAll(): Map<FromId, FromRegistered> = to.getAll().asSequence().associate { (k, v) ->
+        k.toInnerKey() to v.toInnerValue()
+    }
+
     override suspend fun getById(id: FromId): FromRegistered? = to.getById(
         id.toOutKey()
     ) ?.toInnerValue()

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/KeyValueMappers.kt

@@ -55,6 +55,10 @@ open class MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
         key.toOutKey()
     )
 
+    override suspend fun getAll(): Map<FromKey, FromValue> = to.getAll().map { (k, v) ->
+        k.toInnerKey() to v.toInnerValue()
+    }.toMap()
+
     override suspend fun count(): Long = to.count()
 }
 

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/CRUDPaginationExtensions.kt

@@ -1,12 +1,19 @@
 package dev.inmo.micro_utils.repos.pagination
 
+import dev.inmo.micro_utils.common.toCoercedInt
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
 
 suspend inline fun <T, ID, REPO : ReadCRUDRepo<T, ID>> REPO.getAll(
+    pagination: Pagination,
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>
-): List<T> = getAllWithNextPaging {
+): List<T> = getAllWithNextPaging(pagination) {
     methodCaller(this, it)
 }
+
+suspend inline fun <T, ID, REPO : ReadCRUDRepo<T, ID>> REPO.getAll(
+    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>
+): List<T> = getAll(maxPagePagination(), methodCaller)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/KeyValuePaginationExtensions.kt

@@ -1,15 +1,22 @@
 package dev.inmo.micro_utils.repos.pagination
 
+import dev.inmo.micro_utils.common.toCoercedInt
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 
 suspend inline fun <Key, Value, REPO : ReadKeyValueRepo<Key, Value>> REPO.getAll(
+    pagination: Pagination,
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
-): List<Pair<Key, Value>> = getAllWithNextPaging {
+): List<Pair<Key, Value>> = getAllWithNextPaging(pagination) {
     val result = methodCaller(it)
     result.changeResultsUnchecked(
         result.results.mapNotNull { it to (get(it) ?: return@mapNotNull null) }
     )
 }
+
+suspend inline fun <Key, Value, REPO : ReadKeyValueRepo<Key, Value>> REPO.getAll(
+    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
+): List<Pair<Key, Value>> = getAll(maxPagePagination(), methodCaller)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/MaxPagePagination.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.repos.pagination
+
+import dev.inmo.micro_utils.common.toCoercedInt
+import dev.inmo.micro_utils.pagination.FirstPagePagination
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+
+suspend inline fun ReadCRUDRepo<*, *>.maxPagePagination() = FirstPagePagination(count().toCoercedInt())
+suspend inline fun ReadKeyValueRepo<*, *>.maxPagePagination() = FirstPagePagination(count().toCoercedInt())
+suspend inline fun ReadKeyValuesRepo<*, *>.maxPagePagination() = FirstPagePagination(count().toCoercedInt())

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/OneToManyPaginationExtensions.kt

@@ -1,13 +1,15 @@
 package dev.inmo.micro_utils.repos.pagination
 
+import dev.inmo.micro_utils.common.toCoercedInt
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 
 suspend inline fun <Key, Value, REPO : ReadKeyValuesRepo<Key, Value>> REPO.getAll(
+    pagination: Pagination,
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
-): List<Pair<Key, List<Value>>> = getAllWithNextPaging {
+): List<Pair<Key, List<Value>>> = getAllWithNextPaging(pagination) {
     val keysResult = methodCaller(it)
     keysResult.changeResultsUnchecked(
         keysResult.results.map { k ->
@@ -15,3 +17,8 @@ suspend inline fun <Key, Value, REPO : ReadKeyValuesRepo<Key, Value>> REPO.getAl
         }
     )
 }
+
+suspend inline fun <Key, Value, REPO : ReadKeyValuesRepo<Key, Value>> REPO.getAll(
+    @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
+    crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
+): List<Pair<Key, List<Value>>> = getAll(maxPagePagination(), methodCaller)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/crud/ReadCRUDFromKeyValueRepo.kt

@@ -12,6 +12,8 @@ open class ReadCRUDFromKeyValueRepo<RegisteredType, IdType>(
 
     override suspend fun count(): Long = original.count()
 
+    override suspend fun getAll(): Map<IdType, RegisteredType> = original.getAll()
+
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<RegisteredType> = original.values(pagination)
 
     override suspend fun getIdsByPagination(pagination: Pagination): PaginationResult<IdType> = original.keys(pagination)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/ReadKeyValueFromCRUDRepo.kt

@@ -11,6 +11,7 @@ import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+import dev.inmo.micro_utils.repos.pagination.getAll
 import dev.inmo.micro_utils.repos.transforms.kvs.ReadKeyValuesFromKeyValueRepo
 import kotlin.jvm.JvmInline
 
@@ -40,6 +41,8 @@ value class ReadKeyValueFromCRUDRepo<Key, Value>(
         }
     }
 
+    override suspend fun getAll(): Map<Key, Value> = original.getAll()
+
     override suspend fun count(): Long = original.count()
 
     override suspend fun contains(key: Key): Boolean = original.contains(key)

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/transforms/kv/ReadKeyValueFromKeyValuesRepo.kt

@@ -41,6 +41,8 @@ open class ReadKeyValueFromKeyValuesRepo<Key, Value>(
         return original.contains(key)
     }
 
+    override suspend fun getAll(): Map<Key, List<Value>> = original.getAll()
+
     override suspend fun keys(v: List<Value>, pagination: Pagination, reversed: Boolean): PaginationResult<Key> {
         val keys = mutableSetOf<Key>()
 

repos/common/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/FileKeyValueRepo.kt

@@ -1,6 +1,7 @@
 package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.common.filename
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.reverse
 import kotlinx.coroutines.*
@@ -94,6 +95,8 @@ class FileReadKeyValueRepo(
         return File(folder, key).exists()
     }
 
+    override suspend fun getAll(): Map<String, File> = (folder.listFiles() ?.toList() ?: emptyList()).associateBy { it.filename.name }
+
     override suspend fun count(): Long = folder.list() ?.size ?.toLong() ?: 0L
 }
 

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/crud/AbstractAndroidCRUDRepo.kt

@@ -32,6 +32,18 @@ abstract class AbstractAndroidCRUDRepo<ObjectType, IdType>(
         }
     }
 
+    override suspend fun getAll(): Map<IdType, ObjectType> = helper.readableTransaction {
+        select(
+            tableName,
+            null,
+            ""
+        ).use {
+            it.map {
+                it.toId() to it.toObject()
+            }
+        }
+    }.toMap()
+
     override suspend fun getById(id: IdType): ObjectType? = helper.readableTransaction {
         select(
             tableName,

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/keyvalue/KeyValueStore.kt

@@ -104,6 +104,15 @@ class KeyValueStore<T : Any> internal constructor (
 
     override suspend fun contains(key: String): Boolean = sharedPreferences.contains(key)
 
+    override suspend fun getAll(): Map<String, T> {
+        val resultMap = mutableMapOf<String, T>()
+        for ((k, v) in sharedPreferences.all) {
+            @Suppress("UNCHECKED_CAST")
+            resultMap[k] = (v as? T) ?: continue
+        }
+        return resultMap.toMap()
+    }
+
     override suspend fun count(): Long = sharedPreferences.all.size.toLong()
 
     override suspend fun set(toSet: Map<String, T>) {

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

@@ -45,5 +45,9 @@ abstract class AbstractExposedReadCRUDRepo<ObjectType, IdType>(
         select { selectById(id) }.limit(1).any()
     }
 
+    override suspend fun getAll(): Map<IdType, ObjectType> = transaction(database) {
+        selectAll().associate { it.asId to it.asObject }
+    }
+
     override suspend fun count(): Long = transaction(db = database) { selectAll().count() }
 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedReadKeyValueRepo.kt

@@ -5,7 +5,6 @@ import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.*
 import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
 
 abstract class AbstractExposedReadKeyValueRepo<Key, Value>(
@@ -32,6 +31,8 @@ abstract class AbstractExposedReadKeyValueRepo<Key, Value>(
         select { selectById(key) }.limit(1).any()
     }
 
+    override suspend fun getAll(): Map<Key, Value> = transaction(database) { selectAll().associate { it.asKey to it.asObject } }
+
     override suspend fun count(): Long = transaction(database) { selectAll().count() }
 
     override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapCRUDRepo.kt

@@ -26,6 +26,8 @@ class ReadMapCRUDRepo<ObjectType, IdType>(
 
     override suspend fun contains(id: IdType): Boolean = map.containsKey(id)
 
+    override suspend fun getAll(): Map<IdType, ObjectType> = map.toMap()
+
     override suspend fun count(): Long = map.size.toLong()
 }
 

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt

@@ -51,6 +51,8 @@ class ReadMapKeyValueRepo<Key, Value>(
         }
     }
 
+    override suspend fun getAll(): Map<Key, Value> = map.toMap()
+
     override suspend fun contains(key: Key): Boolean = map.containsKey(key)
 
     override suspend fun count(): Long = map.size.toLong()

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorCRUDRepoClient.kt

@@ -44,6 +44,7 @@ class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
                 typeInfo<PaginationResult<ObjectType>>(),
                 typeInfo<PaginationResult<IdType>>(),
                 contentType,
+                typeInfo<Map<IdType, ObjectType>>(),
                 idSerializer
             ),
             KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorReadCRUDRepoClient.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.getAllRoute
 import dev.inmo.micro_utils.repos.ktor.common.idParameterName
 import io.ktor.client.HttpClient
 import io.ktor.client.call.body
@@ -21,6 +22,7 @@ class KtorReadCRUDRepoClient<ObjectType, IdType> (
     private val paginationObjectType: TypeInfo,
     private val paginationIdType: TypeInfo,
     private val contentType: ContentType,
+    private val mapTypeInfo: TypeInfo,
     private val idSerializer: suspend (IdType) -> String
 ) : ReadCRUDRepo<ObjectType, IdType> {
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = httpClient.get(
@@ -58,6 +60,15 @@ class KtorReadCRUDRepoClient<ObjectType, IdType> (
         contentType(contentType)
     }.body()
 
+    override suspend fun getAll(): Map<IdType, ObjectType> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            getAllRoute
+        )
+    ) {
+        contentType(contentType)
+    }.body(mapTypeInfo)
+
     override suspend fun count(): Long = httpClient.get(
         buildStandardUrl(
             baseUrl,
@@ -80,6 +91,7 @@ inline fun <reified ObjectType, IdType> KtorReadCRUDRepoClient(
     typeInfo<PaginationResult<ObjectType>>(),
     typeInfo<PaginationResult<IdType>>(),
     contentType,
+    typeInfo<Map<IdType, ObjectType>>(),
     idSerializer
 )
 

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key/value/KtorReadKeyValueRepoClient.kt

@@ -23,6 +23,7 @@ class KtorReadKeyValueRepoClient<Key, Value>(
     private val objectType: TypeInfo,
     private val paginationResultObjectsTypeInfo: TypeInfo,
     private val paginationResultIdsTypeInfo: TypeInfo,
+    private val mapKeyValueTypeInfo: TypeInfo,
     private val idSerializer: suspend (Key) -> String,
     private val valueSerializer: suspend (Value) -> String
 ) : ReadKeyValueRepo<Key, Value> {
@@ -48,6 +49,15 @@ class KtorReadKeyValueRepoClient<Key, Value>(
         contentType(contentType)
     }.body()
 
+    override suspend fun getAll(): Map<Key, Value> = httpClient.get(
+        buildStandardUrl(
+            baseUrl,
+            getAllRoute
+        )
+    ) {
+        contentType(contentType)
+    }.body(mapKeyValueTypeInfo)
+
     override suspend fun values(
         pagination: Pagination,
         reversed: Boolean
@@ -103,6 +113,7 @@ inline fun <reified Key, reified Value> KtorReadKeyValueRepoClient(
     typeInfo<Value>(),
     typeInfo<PaginationResult<Value>>(),
     typeInfo<PaginationResult<Key>>(),
+    typeInfo<Map<Key, Value>>(),
     idSerializer,
     valueSerializer
 )

repos/ktor/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/common/GetAllRoute.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.repos.ktor.common
+
+const val getAllRoute = "getAll"

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

@@ -83,6 +83,9 @@ class CRUDTests {
             assertEquals(map.size, 0)
             assertEquals(map.size.toLong(), crudClient.count())
             assertEquals(0, crudClient.count())
+
+            assertEquals(map, crudClient.getAll())
+
             server.stop()
         }
     }

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

@@ -133,6 +133,8 @@ class KVTests {
                 crudClient.count()
             )
 
+            assertEquals(map, crudClient.getAll())
+
             server.stop()
         }
     }

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadCRUDRepoRoutes.kt

@@ -6,6 +6,7 @@ import dev.inmo.micro_utils.pagination.extractPagination
 import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import dev.inmo.micro_utils.repos.ktor.common.getAllRoute
 import dev.inmo.micro_utils.repos.ktor.common.idParameterName
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.call
@@ -53,6 +54,10 @@ inline fun <reified ObjectType, reified IdType> Route.configureReadCRUDRepoRoute
         )
     }
 
+    get(getAllRoute) {
+        call.respond(originalRepo.getAll())
+    }
+
     get(countRouting) {
         call.respond(
             originalRepo.count()

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

@@ -70,6 +70,10 @@ inline fun <reified Key, reified Value> Route.configureReadKeyValueRepoRoutes (
         call.respond(originalRepo.contains(key))
     }
 
+    get(getAllRoute) {
+        call.respond(originalRepo.getAll())
+    }
+
     get(countRoute) {
         call.respond(originalRepo.count())
     }

serialization/mapper/build.gradle

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

serialization/mapper/src/commonMain/kotlin/Extensions.kt

@@ -0,0 +1,99 @@
+package dev.inmo.micro_utils.serialization.mapper
+
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.InternalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.serializer
+import kotlin.reflect.KClass
+
+/**
+ * Will create [MapperSerializationStrategy] to allow you to map [O] to [I] using [serialize] lambda during
+ * serialization process
+ */
+inline fun <reified I : Any, O> SerializationStrategy<I>.mapSerialization(
+    noinline serialize: (O) -> I
+) = MapperSerializationStrategy(
+    this,
+    serialize
+)
+
+/**
+ * Will create [MapperDeserializationStrategy] to allow you to map [I] to [O] using [deserialize] lambda during
+ * deserialization process
+ */
+inline fun <reified I : Any, O> DeserializationStrategy<I>.mapDeserialization(
+    noinline deserialize: (I) -> O
+) = MapperDeserializationStrategy(
+    this,
+    deserialize
+)
+
+/**
+ * Will create [MapperSerializer] to allow you to map [O] to [I] and vice verse using [serialize]/[deserialize] lambda during
+ * serialization/deserialization process
+ */
+inline fun <reified I : Any, O> KSerializer<I>.mapFullSerialization(
+    noinline serialize: (O) -> I,
+    noinline deserialize: (I) -> O
+) = MapperSerializer(
+    this,
+    serialize,
+    deserialize
+)
+
+/**
+ * Will create [MapperSerializationStrategy] to allow you to map [O] to [I] using [serialize] lambda during
+ * serialization process
+ */
+@OptIn(InternalSerializationApi::class)
+inline fun <reified I : Any, O> KClass<I>.mapSerialization(
+    serializer: SerializationStrategy<I> = serializer(),
+    noinline serialize: (O) -> I
+) = serializer.mapSerialization(serialize)
+
+/**
+ * Will create [MapperDeserializationStrategy] to allow you to map [I] to [O] using [deserialize] lambda during
+ * deserialization process
+ */
+@OptIn(InternalSerializationApi::class)
+inline fun <reified I : Any, O> KClass<I>.mapDeserialization(
+    serializer: DeserializationStrategy<I> = serializer(),
+    noinline deserialize: (I) -> O
+) = serializer.mapDeserialization(deserialize)
+
+/**
+ * Will create [MapperSerializer] to allow you to map [O] to [I] and vice verse using [serialize]/[deserialize] lambda during
+ * serialization/deserialization process
+ */
+@OptIn(InternalSerializationApi::class)
+inline fun <reified I : Any, O> KClass<I>.mapFullSerialization(
+    serializer: KSerializer<I> = serializer(),
+    noinline serialize: (O) -> I,
+    noinline deserialize: (I) -> O
+) = serializer.mapFullSerialization(serialize, deserialize)
+
+/**
+ * Will create [MapperSerializationStrategy] to allow you to map [O] to [I] using [serialize] lambda during
+ * serialization process
+ */
+inline fun <reified I : Any, O> mappedSerializationStrategy(
+    noinline serialize: (O) -> I,
+) = serializer<I>().mapSerialization(serialize)
+
+/**
+ * Will create [MapperDeserializationStrategy] to allow you to map [I] to [O] using [deserialize] lambda during
+ * deserialization process
+ */
+inline fun <reified I : Any, O> mappedDeserializationStrategy(
+    noinline deserialize: (I) -> O
+) = serializer<I>().mapDeserialization(deserialize)
+
+/**
+ * Will create [MapperSerializer] to allow you to map [O] to [I] and vice verse using [serialize]/[deserialize] lambda during
+ * serialization/deserialization process
+ */
+inline fun <reified I : Any, O> mappedSerializer(
+    noinline serialize: (O) -> I,
+    noinline deserialize: (I) -> O
+) = serializer<I>().mapFullSerialization(serialize, deserialize)

serialization/mapper/src/commonMain/kotlin/MapperDeserializationStrategy.kt

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.serialization.mapper
+
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * Use this serializer when you have deserializable type [I] and want to map it to some [O] in process of
+ * deserialization
+ *
+ * @param base Serializer for [I]
+ * @param deserialize Will be used in [deserialize] method to convert deserialized by [base] [I] to [O]
+ */
+open class MapperDeserializationStrategy<I, O>(
+    private val base: DeserializationStrategy<I>,
+    private val deserialize: (I) -> O
+) : DeserializationStrategy<O> {
+    override val descriptor: SerialDescriptor = base.descriptor
+
+    override fun deserialize(decoder: Decoder): O {
+        return deserialize(base.deserialize(decoder))
+    }
+}

serialization/mapper/src/commonMain/kotlin/MapperSerializationStrategy.kt

@@ -0,0 +1,25 @@
+package dev.inmo.micro_utils.serialization.mapper
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * Use this serializer when you have serializable type [I] and want to map it to some [O] in process of
+ * serialization
+ *
+ * @param base Serializer for [I]
+ * @param serialize Will be used in [serialize] method to convert incoming [O] to [I] and serialize with [base]
+ */
+open class MapperSerializationStrategy<I, O>(
+    private val base: SerializationStrategy<I>,
+    private val serialize: (O) -> I
+) : SerializationStrategy<O> {
+    override val descriptor: SerialDescriptor = base.descriptor
+
+    override fun serialize(encoder: Encoder, value: O) {
+        base.serialize(encoder, serialize(value))
+    }
+}

serialization/mapper/src/commonMain/kotlin/MapperSerializer.kt

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.serialization.mapper
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * Use this serializer when you have serializable type [I] and want to map it to some [O] in process of
+ * serialization/deserialization
+ *
+ * @param base Serializer for [I]
+ * @param serialize Will be used in [serialize] method to convert incoming [O] to [I] and serialize with [base]
+ * @param deserialize Will be used in [deserialize] method to convert deserialized by [base] [I] to [O]
+ */
+open class MapperSerializer<I, O>(
+    private val base: KSerializer<I>,
+    private val serialize: (O) -> I,
+    private val deserialize: (I) -> O
+) : KSerializer<O> {
+    override val descriptor: SerialDescriptor = base.descriptor
+
+    override fun deserialize(decoder: Decoder): O {
+        return deserialize(base.deserialize(decoder))
+    }
+
+    override fun serialize(encoder: Encoder, value: O) {
+        base.serialize(encoder, serialize(value))
+    }
+}

serialization/mapper/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.serialization.mapper"/>

settings.gradle

@@ -37,6 +37,7 @@ String[] includes = [
     ":serialization:base64",
     ":serialization:encapsulator",
     ":serialization:typed_serializer",
+    ":serialization:mapper",
     ":startup:plugin",
     ":startup:launcher",
 

startup/launcher/build.gradle

@@ -4,7 +4,7 @@ plugins {
     id "application"
 }
 
-apply from: "$mppJsAndJavaProjectPresetPath"
+apply from: "$mppJvmJsLinuxMingwProjectPresetPath"
 
 kotlin {
     sourceSets {

startup/plugin/build.gradle

@@ -3,7 +3,7 @@ plugins {
     id "org.jetbrains.kotlin.plugin.serialization"
 }
 
-apply from: "$mppJsAndJavaProjectPresetPath"
+apply from: "$mppJvmJsLinuxMingwProjectPresetPath"
 
 kotlin {
     sourceSets {
@@ -21,5 +21,15 @@ kotlin {
                 api libs.uuid
             }
         }
+        linuxX64Main {
+            dependencies {
+                api libs.uuid
+            }
+        }
+        mingwX64Main {
+            dependencies {
+                api libs.uuid
+            }
+        }
     }
 }

startup/plugin/src/linuxX64Main/kotlin/StartPluginSerializer.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.startup.plugin
+
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlin.reflect.KClass
+
+actual object StartPluginSerializer : KSerializer<StartPlugin> {
+    private val registeredPlugins = mutableMapOf<String, StartPlugin>()
+    private val registeredPluginsByPlugin = mutableMapOf<StartPlugin, String>()
+    override val descriptor: SerialDescriptor = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): StartPlugin {
+        val name = decoder.decodeString()
+        return registeredPlugins[name] ?: error("Unable to find startup plugin for $name")
+    }
+
+    override fun serialize(encoder: Encoder, value: StartPlugin) {
+        val name = registeredPluginsByPlugin[value] ?: uuid4().toString().also {
+            registeredPlugins[it] = value
+            registeredPluginsByPlugin[value] = it
+        }
+        encoder.encodeString(name)
+    }
+
+    /**
+     * Register plugin inside of this [KSerializer]. Since plugin has been registered, you may use its [name] in any
+     * serialized [dev.inmo.micro_utils.startup.launcher.Config] to retrieve [plugin] you passed here
+     */
+    fun registerPlugin(name: String, plugin: StartPlugin) {
+        registeredPlugins[name] = plugin
+    }
+}

startup/plugin/src/mingwX64Main/kotlin/StartPluginSerializer.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.startup.plugin
+
+import com.benasher44.uuid.uuid4
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlin.reflect.KClass
+
+actual object StartPluginSerializer : KSerializer<StartPlugin> {
+    private val registeredPlugins = mutableMapOf<String, StartPlugin>()
+    private val registeredPluginsByPlugin = mutableMapOf<StartPlugin, String>()
+    override val descriptor: SerialDescriptor = String.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): StartPlugin {
+        val name = decoder.decodeString()
+        return registeredPlugins[name] ?: error("Unable to find startup plugin for $name")
+    }
+
+    override fun serialize(encoder: Encoder, value: StartPlugin) {
+        val name = registeredPluginsByPlugin[value] ?: uuid4().toString().also {
+            registeredPlugins[it] = value
+            registeredPluginsByPlugin[value] = it
+        }
+        encoder.encodeString(name)
+    }
+
+    /**
+     * Register plugin inside of this [KSerializer]. Since plugin has been registered, you may use its [name] in any
+     * serialized [dev.inmo.micro_utils.startup.launcher.Config] to retrieve [plugin] you passed here
+     */
+    fun registerPlugin(name: String, plugin: StartPlugin) {
+        registeredPlugins[name] = plugin
+    }
+}