rework of context exceptions

This reverts commit 9739bd871e.

.travis.yml

@@ -22,5 +22,6 @@ jobs:
   include:
     - stage: build
       script: ./gradlew build -s -x jvmTest -x jsIrTest -x jsIrBrowserTest -x jsIrNodeTest -x jsLegacyTest -x jsLegacyBrowserTest -x jsLegacyNodeTest
-    - state: test
-      script: ./gradlew allTests
+#    Tests are temporarily disabled on public travis due to the problems of launching
+#    - state: test
+#      script: ./gradlew allTests

CHANGELOG.md

@@ -1,5 +1,141 @@
 # Changelog
 
+## 0.4.15
+
+* `Coroutines`:
+    * `safely`:
+        * `SafelyExceptionHandlerKey` has been deprecated
+        * `SafelyExceptionHandler` has been deprecated
+        * `ContextSafelyExceptionHandlerKey` has been added
+        * `ContextSafelyExceptionHandler` has been added
+        * `safelyWithContextExceptionHandler` has been added
+
+## 0.4.14
+
+* `Versions`:
+    * `Kotlin`: `1.4.20` -> `1.4.21`
+    * `Ktor`: `1.4.3` -> `1.5.0`
+    * `Klock`: `2.0.1` -> `2.0.2`
+* `Coroutines`:
+    * Add global variable `defaultSafelyExceptionHandler`
+    * Add `SafelyExceptionHandlerKey` and `SafelyExceptionHandler` classes to be able to overwrite
+    `defaultSafelyExceptionHandler` using context of coroutine
+
+## 0.4.13
+
+* `Common`
+    * `Android`
+        * Add expand/collapse functionality for horizontal expand/collapse
+
+## 0.4.12
+
+* `Coroutines`
+    * `JVM`
+        * Update `launchSynchronously` signature
+* `Selector`
+    * Project created
+
+## 0.4.11
+
+* `Common`
+    * Add `clamp` function
+
+## 0.4.10
+
+* `Versions`:
+    * `Klock`: `2.0.0` -> `2.0.1`
+* `Repo`
+    * Repo `WriteStandardKeyValueRepo` got new method `unsetWithValues`
+
+## 0.4.9
+
+* `Versions`:
+    * `Ktor`: `1.4.2` -> `1.4.3`
+* `Coroutines`:
+    * `launchSynchronously` has been added in JVM
+* `Repo`
+    * `Common`
+        * In repos different usages of `BroadcastChannel`s has been replaced with `MutableSharedFlow`
+    * `Exposed`
+        * `asObject` open fun has been added in CRUD realization
+
+## 0.4.8
+
+* `Versions`:
+    * `Coroutines`: `1.4.1` -> `1.4.2`
+    * `UUID`: `0.2.2` -> `0.2.3`
+* `Pagination`
+    * Add `PaginatedIterable` and `PaginatedIterator`
+
+## 0.4.7
+
+* `Ktor`
+    * `Client`
+        * New class `UnifiedRequester`
+    * `Server`
+        * New class `UnifiedRouter`
+* `Repos`
+    * `Ktor`
+        * `Client`
+            * Rewriting of all clients on new `UnifiedRequester`
+        * `Server`
+            * Rewriting of all clients on new `UnifiedRouter`
+
+## 0.4.6
+
+* `Common`
+    * New annotation `Warning` has been added
+* `Pagination`
+    * `Common`
+        * `Pagination` got new extension: `Pagination#isFirstPage`
+* `Coroutines`:
+    * New extension `FlowCollector#invoke` has been added
+* `Repos`
+    * `Common`
+        * `JVM` (and `Android` since `Android API 26`):
+            * `FileStandardKeyValueRepo` has been added
+        * Add several `typealias`es for each type of repos
+
+## 0.4.5
+
+* `Android`
+    * `Alerts`
+        * `Common`
+            * Project has been created
+        * `RecyclerView`
+            * Project has been created
+* `Common`
+    * Annotation `PreviewFeature` has been added
+    * `Android`
+        * Added tools to work with visibility in more comfortable way
+        * Added tools to work with disabled/enabled state in more comfortable way
+        * Added tools to work with expanded/collapsed state in more comfortable way (in preview mode)
+
+## 0.4.4
+
+* `Versions`:
+    * `Klock`: `1.12.1` -> `2.0.0`
+* `Commons`:
+    * Update left items functionality to include work with `GridLayoutManager`
+* `Repos`:
+    * Add interface `VersionsRepo`
+        * Add default realization of `VersionsRepo` named `StandardVersionsRepo` which use `StandardVersionsRepoProxy`
+        to get access to some end-store
+        * Add default realization of `StandardVersionsRepoProxy` based on `KeyValue` repos
+        * Add realizations of `StandardVersionsRepoProxy` for exposed and android (`SQL` and `SharedPreferences`)
+    * `Commons`:
+        * In Android fully reworked transactions functions
+        * Now `DatabaseCoroutineContext` is a shortcut for `Dispatchers.IO`
+
+## 0.4.3
+
+* `Versions`:
+    * `Kotlin`: `1.4.10` -> `1.4.20`
+* `Common`:
+    * Two new extensions for Android:
+        * `Resources#getSp`
+        * `Resources#getDp`
+
 ## 0.4.2
 
 * `Repos`:
@@ -235,4 +371,4 @@ All deprecations has been removed
 
 ## 0.1.0
 
-Inited :)
+Inited :)

README.md

@@ -1 +1,36 @@
-# MicroUtils
+# MicroUtils
+
+This is a library with collection of tools for working in Kotlin environment. First of all, this library collection is oriented to use next technologies:
+
+* [`Kotlin Coroutines`](https://github.com/Kotlin/kotlinx.coroutines)
+* [`Kotlin Serialization`](https://github.com/Kotlin/kotlinx.serialization)
+* [`Kotlin Exposed`](https://github.com/JetBrains/Exposed)
+* [`Ktor`](https://ktor.io)
+
+<details>
+  <summary> <b>Android environment</b> </summary>
+
+You always can look at the <a href="https://github.com/InsanusMokrassar/MicroUtils/blob/master/gradle.properties#L24-L34">properties file</a> to get information about current project dependencies, compile and build tools for `Android` target.
+
+</details>
+
+## Projects
+
+* `common` contains common tools for platform which usually are absent out-of-the-box when you starting project
+* `selector` contains tools to use `Selector` interface with things like `RecyclerView` in android or other selection needs
+* `coroutines` is a module for `Kotlin Coroutines` with different things like subscribing on flows (`onEach` + `launchIn` shortcut :) )
+* `ktor` is a set of modules for `client`s and `server`s
+* `mime_types` is NOT lightweight set of `MimeType`s with a lot of different objected and serializable (with `Kotlin Serialization`) mime types
+* `pagination` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for lightweight pagination
+* `repos` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for `KeyValue`/`OneToMany`/`CRUD` repos created to be able to exclude some heavy dependencies when you need some simple and lightweight typical repositories
+
+## Complex modules structure
+
+Most of complex modules are built with next hierarchy:
+
+* `common` submodule for `API` things which are common for all platforms
+* `exposed` submodule contains realizations for exposed tables
+* `ktor` submodule is usually unavailable directly, because it contains its own submodules for clients and servers
+    * `common` part contains routes which are common for clients and servers
+    * `client` submodule contains clients which are usually using `UnifiedRequester` to make requests using routes from `ktor/common` module and some internal logic of requests
+    * `server` submodule (in most cases `JVM`-only) contains some extensions for `Route` instances which usually will give opportunity to proxy internet requests from `ktor/client` realization to some proxy object

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

android/alerts/common/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppAndroidProjectPresetPath"
+
+kotlin {
+    sourceSets {
+        androidMain {
+            dependencies {
+                api "androidx.appcompat:appcompat-resources:$appcompat_version"
+            }
+        }
+    }
+}

android/alerts/common/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.android.alerts.common"/>

android/alerts/common/src/main/kotlin/dev/inmo/micro_utils/android/alerts/common/AlertDialog.kt

@@ -0,0 +1,55 @@
+@file:Suppress("NOTHING_TO_INLINE", "unused")
+
+package dev.inmo.micro_utils.android.alerts.common
+
+import android.app.AlertDialog
+import android.content.Context
+import android.content.DialogInterface
+
+typealias AlertDialogCallback = (DialogInterface) -> Unit
+
+inline fun Context.createAlertDialogTemplate(
+    title: String? = null,
+    positivePair: Pair<String, AlertDialogCallback?>? = null,
+    neutralPair: Pair<String, AlertDialogCallback?>? = null,
+    negativePair: Pair<String, AlertDialogCallback?>? = null
+): AlertDialog.Builder {
+    val builder = AlertDialog.Builder(this)
+
+    title ?.let {
+        builder.setTitle(title)
+    }
+
+    positivePair ?. let {
+        builder.setPositiveButton(it.first) { di, _ -> it.second ?. invoke(di) }
+    }
+    negativePair ?. let {
+        builder.setNegativeButton(it.first) { di, _ -> it.second ?. invoke(di) }
+    }
+    neutralPair ?. let {
+        builder.setNeutralButton(it.first) { di, _ -> it.second ?. invoke(di) }
+    }
+
+    return builder
+}
+
+inline fun Context.createAlertDialogTemplateWithResources(
+    title: Int? = null,
+    positivePair: Pair<Int, AlertDialogCallback?>? = null,
+    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
+    negativePair: Pair<Int, AlertDialogCallback?>? = null
+): AlertDialog.Builder = createAlertDialogTemplate(
+    title ?.let { getString(it) },
+    positivePair ?.let { getString(it.first) to it.second },
+    neutralPair ?.let { getString(it.first) to it.second },
+    negativePair ?.let { getString(it.first) to it.second }
+)
+
+inline fun AlertDialog.setDismissChecker(noinline checker: () -> Boolean) : AlertDialog {
+    setOnDismissListener {
+        if (!checker()) {
+            show()
+        }
+    }
+    return this
+}

android/alerts/common/src/main/kotlin/dev/inmo/micro_utils/android/alerts/common/CustomAlertDialog.kt

@@ -0,0 +1,38 @@
+@file:Suppress("NOTHING_TO_INLINE", "unused")
+
+package dev.inmo.micro_utils.android.alerts.common
+
+import android.app.AlertDialog
+import android.content.Context
+import android.view.View
+
+inline fun <T: View> Context.createCustomViewAlertDialog(
+    title: String? = null,
+    positivePair: Pair<String, AlertDialogCallback?>? = null,
+    neutralPair: Pair<String, AlertDialogCallback?>? = null,
+    negativePair: Pair<String, AlertDialogCallback?>? = null,
+    show: Boolean = true,
+    viewCreator: (Context) -> T
+): AlertDialog = createAlertDialogTemplate(
+    title, positivePair, neutralPair, negativePair
+).apply {
+    setView(viewCreator(this@createCustomViewAlertDialog))
+}.create().apply {
+    if (show) show()
+}
+
+inline fun <T: View> Context.createCustomViewAlertDialogWithResources(
+    title: Int? = null,
+    positivePair: Pair<Int, AlertDialogCallback?>? = null,
+    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
+    negativePair: Pair<Int, AlertDialogCallback?>? = null,
+    show: Boolean = true,
+    viewCreator: (Context) -> T
+): AlertDialog = createCustomViewAlertDialog(
+    title ?.let { getString(it) },
+    positivePair ?.let { getString(it.first) to it.second },
+    neutralPair ?.let { getString(it.first) to it.second },
+    negativePair ?.let { getString(it.first) to it.second },
+    show,
+    viewCreator
+)

android/alerts/common/src/main/kotlin/dev/inmo/micro_utils/android/alerts/common/SimpleTextAlert.kt

@@ -0,0 +1,45 @@
+@file:Suppress("NOTHING_TO_INLINE", "unused")
+
+package dev.inmo.micro_utils.android.alerts.common
+
+import android.app.AlertDialog
+import android.content.Context
+import androidx.annotation.StringRes
+
+inline fun Context.createSimpleTextAlertDialog(
+    text: String,
+    title: String? = null,
+    positivePair: Pair<String, AlertDialogCallback?>? = null,
+    neutralPair: Pair<String, AlertDialogCallback?>? = null,
+    negativePair: Pair<String, AlertDialogCallback?>? = null,
+    show: Boolean = true
+): AlertDialog = createAlertDialogTemplate(
+    title,
+    positivePair,
+    neutralPair,
+    negativePair
+).apply {
+    setMessage(text)
+}.create().apply {
+    if (show) {
+        show()
+    }
+}
+
+inline fun Context.createSimpleTextAlertDialog(
+    @StringRes
+    text: Int,
+    @StringRes
+    title: Int? = null,
+    positivePair: Pair<Int, AlertDialogCallback?>? = null,
+    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
+    negativePair: Pair<Int, AlertDialogCallback?>? = null,
+    show: Boolean = true
+): AlertDialog = createSimpleTextAlertDialog(
+    getString(text),
+    title ?.let { getString(it) },
+    positivePair ?.let { getString(it.first) to it.second },
+    neutralPair ?.let { getString(it.first) to it.second },
+    negativePair ?.let { getString(it.first) to it.second },
+    show
+)

android/alerts/recyclerview/build.gradle

@@ -0,0 +1,18 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppAndroidProjectPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api internalProject("micro_utils.android.alerts.common")
+                api internalProject("micro_utils.android.recyclerview")
+            }
+        }
+    }
+}

android/alerts/recyclerview/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.android.alerts.recyclerview"/>

android/alerts/recyclerview/src/main/kotlin/dev/inmo/micro_utils/android/alerts/recyclerview/ActionsAlerts.kt

@@ -0,0 +1,65 @@
+@file:Suppress("unused")
+
+package dev.inmo.micro_utils.android.alerts.recyclerview
+
+import android.app.AlertDialog
+import android.content.Context
+import android.content.DialogInterface
+import android.view.ViewGroup
+import android.widget.TextView
+import dev.inmo.micro_utils.android.alerts.common.AlertDialogCallback
+import dev.inmo.micro_utils.android.recyclerview.*
+
+data class AlertAction(
+    val title: String,
+    val callback: (DialogInterface) -> Unit
+)
+
+private class ActionViewHolder(
+    container: ViewGroup, dialogInterfaceGetter: () -> DialogInterface
+) : AbstractStandardViewHolder<AlertAction>(container, android.R.layout.simple_list_item_1) {
+    private lateinit var action: AlertAction
+    private val textView: TextView
+        get() = itemView.findViewById(android.R.id.text1)
+
+    init {
+        itemView.setOnClickListener {
+            action.callback(dialogInterfaceGetter())
+        }
+    }
+
+    override fun onBind(item: AlertAction) {
+        action = item
+        textView.text = item.title
+    }
+}
+
+private class ActionsRecyclerViewAdapter(
+    data: List<AlertAction>,
+    private val dialogInterfaceGetter: () -> DialogInterface
+) : RecyclerViewAdapter<AlertAction>(data) {
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AbstractViewHolder<AlertAction> = ActionViewHolder(
+        parent, dialogInterfaceGetter
+    )
+}
+
+fun Context.createActionsAlertDialog(
+    actions: List<AlertAction>,
+    title: Int? = null,
+    positivePair: Pair<Int, AlertDialogCallback?>? = null,
+    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
+    negativePair: Pair<Int, AlertDialogCallback?>? = null,
+    show: Boolean = true
+): AlertDialog {
+    lateinit var dialogInterface: DialogInterface
+
+    return createRecyclerViewDialog(
+        title, positivePair, neutralPair, negativePair, show
+    ) {
+        ActionsRecyclerViewAdapter(
+            actions
+        ) {
+            dialogInterface
+        }
+    }.also { dialogInterface = it }
+}

android/alerts/recyclerview/src/main/kotlin/dev/inmo/micro_utils/android/alerts/recyclerview/RecyclerViewDialog.kt

@@ -0,0 +1,43 @@
+package dev.inmo.micro_utils.android.alerts.recyclerview
+
+import android.app.AlertDialog
+import android.content.Context
+import android.widget.LinearLayout
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import dev.inmo.micro_utils.android.alerts.common.AlertDialogCallback
+import dev.inmo.micro_utils.android.alerts.common.createCustomViewAlertDialogWithResources
+
+fun Context.createRecyclerViewDialog(
+    title: Int? = null,
+    positivePair: Pair<Int, AlertDialogCallback?>? = null,
+    neutralPair: Pair<Int, AlertDialogCallback?>? = null,
+    negativePair: Pair<Int, AlertDialogCallback?>? = null,
+    show: Boolean = true,
+    layoutManager: RecyclerView.LayoutManager = LinearLayoutManager(this),
+    marginOfRecyclerView: Int = 8, // dp
+    recyclerViewSetUp: RecyclerView.() -> Unit = {},
+    adapterFactory: () -> RecyclerView.Adapter<*>
+): AlertDialog {
+    val recyclerView = RecyclerView(this).apply {
+        layoutParams = LinearLayout.LayoutParams(
+            LinearLayout.LayoutParams.MATCH_PARENT,
+            LinearLayout.LayoutParams.WRAP_CONTENT
+        ).apply {
+            setMargins(marginOfRecyclerView, marginOfRecyclerView, marginOfRecyclerView, marginOfRecyclerView)
+        }
+        this.layoutManager = layoutManager
+        adapter = adapterFactory()
+        recyclerViewSetUp()
+    }
+
+    return createCustomViewAlertDialogWithResources(
+        title,
+        positivePair,
+        neutralPair,
+        negativePair,
+        show
+    ) {
+        recyclerView
+    }
+}

android/recyclerview/build.gradle

@@ -2,7 +2,6 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
     id "com.android.library"
-    id "kotlin-android-extensions"
 }
 
 apply from: "$mppAndroidProjectPresetPath"

android/recyclerview/src/main/kotlin/dev/inmo/micro_utils/android/recyclerview/LeftItems.kt

@@ -1,14 +1,20 @@
 package dev.inmo.micro_utils.android.recyclerview
 
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.*
 
+@Suppress("NOTHING_TO_INLINE")
+private inline fun RecyclerView.LayoutManager.findLastVisibleItemPositionGetter(): (() -> Int)? = when (this) {
+    is LinearLayoutManager -> ::findLastVisibleItemPosition
+    is GridLayoutManager -> ::findLastVisibleItemPosition
+    else -> null
+}
+
 fun RecyclerView.lastVisibleItemFlow(
     completingScope: CoroutineScope
 ): Flow<Int> {
-    val lastVisibleElementFun: () -> Int = (layoutManager as? LinearLayoutManager) ?.let { it::findLastVisibleItemPosition } ?: error("Currently supported only linear layout manager")
+    val lastVisibleElementFun: () -> Int = layoutManager ?.findLastVisibleItemPositionGetter() ?: error("Currently supported only linear and grid layout manager")
     val lastVisibleFlow = MutableStateFlow(lastVisibleElementFun())
     addOnScrollListener(
         object : RecyclerView.OnScrollListener() {

build.gradle

@@ -8,10 +8,9 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.0'
+        classpath 'com.android.tools.build:gradle:4.0.2'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
         classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
         classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"

common/build.gradle

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

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

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.common
+
+@RequiresOptIn(
+    "It is possible, that behaviour of this thing will be changed or removed in future releases",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.TYPEALIAS,
+    AnnotationTarget.TYPE_PARAMETER
+)
+annotation class PreviewFeature
+
+@RequiresOptIn(
+    "This thing is marked as warned. See message of warn to get more info",
+    RequiresOptIn.Level.WARNING
+)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.TYPEALIAS,
+    AnnotationTarget.TYPE_PARAMETER
+)
+annotation class Warning(val message: String)

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

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.common
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T : Comparable<T>> T.clamp(min: T, max: T): T {
+    return when {
+        this < min -> min
+        this > max -> max
+        else -> this
+    }
+}

common/src/main/kotlin/dev/inmo/micro_utils/common/Dimensions.kt

@@ -0,0 +1,13 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package dev.inmo.micro_utils.common
+
+import android.content.res.Resources
+
+inline fun Resources.getSp(
+    resId: Int
+) = getDimension(resId) / displayMetrics.scaledDensity
+
+inline fun Resources.getDp(
+    resId: Int
+) = getDimension(resId) * displayMetrics.density

common/src/main/kotlin/dev/inmo/micro_utils/common/ExpandCollapse.kt

@@ -0,0 +1,140 @@
+package dev.inmo.micro_utils.common
+
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.Animation
+import android.view.animation.Transformation
+
+private fun View.performExpand(
+    duration: Long = 500,
+    targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT,
+    targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT,
+    onMeasured: View.() -> Unit,
+    onPerformAnimation: View.(interpolatedTime: Float, t: Transformation?) -> Unit
+) {
+    measure(targetWidth, targetHeight)
+    onMeasured()
+    show()
+    val a: Animation = object : Animation() {
+        override fun applyTransformation(interpolatedTime: Float, t: Transformation?) {
+            super.applyTransformation(interpolatedTime, t)
+            onPerformAnimation(interpolatedTime, t)
+            requestLayout()
+        }
+
+        override fun willChangeBounds(): Boolean = true
+    }
+
+    a.duration = duration
+    startAnimation(a)
+}
+
+private fun View.performCollapse(
+    duration: Long = 500,
+    onPerformAnimation: View.(interpolatedTime: Float, t: Transformation?) -> Unit
+) {
+    val a: Animation = object : Animation() {
+        override fun applyTransformation(interpolatedTime: Float, t: Transformation?) {
+            if (interpolatedTime == 1f) {
+                gone()
+            } else {
+                onPerformAnimation(interpolatedTime, t)
+                requestLayout()
+            }
+        }
+
+        override fun willChangeBounds(): Boolean {
+            return true
+        }
+    }
+
+    a.duration = duration
+
+    startAnimation(a)
+}
+
+@PreviewFeature
+fun View.expand(
+    duration: Long = 500,
+    targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT,
+    targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT
+) {
+    var measuredHeight = 0
+    performExpand(
+        duration,
+        targetWidth,
+        targetHeight,
+        {
+            measuredHeight = this.measuredHeight
+        }
+    ) { interpolatedTime, _ ->
+        layoutParams.height = if (interpolatedTime == 1f) targetHeight else (measuredHeight * interpolatedTime).toInt()
+    }
+}
+
+@PreviewFeature
+fun View.expandHorizontally(
+    duration: Long = 500,
+    targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT,
+    targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT
+) {
+    var measuredWidth = 0
+    performExpand(
+        duration,
+        targetWidth,
+        targetHeight,
+        {
+            measuredWidth = this.measuredWidth
+        }
+    ) { interpolatedTime, _ ->
+        layoutParams.width = if (interpolatedTime == 1f) targetWidth else (measuredWidth * interpolatedTime).toInt()
+    }
+}
+
+@PreviewFeature
+fun View.collapse(duration: Long = 500) {
+    val initialHeight: Int = measuredHeight
+    performCollapse(duration) { interpolatedTime, _ ->
+        layoutParams.height = initialHeight - (initialHeight * interpolatedTime).toInt()
+    }
+}
+
+@PreviewFeature
+fun View.collapseHorizontally(duration: Long = 500) {
+    val initialWidth: Int = measuredWidth
+    performCollapse(duration) { interpolatedTime, _ ->
+        layoutParams.width = initialWidth - (initialWidth * interpolatedTime).toInt()
+    }
+}
+
+@PreviewFeature
+inline val View.isCollapsed
+    get() = visibility == View.GONE
+
+@PreviewFeature
+inline val View.isExpanded
+    get() = !isCollapsed
+
+/**
+ * @return true in case of expanding
+ */
+@PreviewFeature
+fun View.toggleExpandState(duration: Long = 500): Boolean = if (isCollapsed) {
+    expand(duration)
+    true
+} else {
+    collapse(duration)
+    false
+}
+
+/**
+ * @return true in case of expanding
+ */
+@PreviewFeature
+fun View.toggleExpandHorizontallyState(duration: Long = 500): Boolean = if (isCollapsed) {
+    expandHorizontally(duration)
+    true
+} else {
+    collapseHorizontally(duration)
+    false
+}

common/src/main/kotlin/dev/inmo/micro_utils/common/ViewDisable.kt

@@ -0,0 +1,34 @@
+@file:Suppress("NOTHING_TO_INLINE", "unused")
+
+package dev.inmo.micro_utils.common
+
+import android.view.View
+import android.view.ViewGroup
+
+inline val View.enabled
+    get() = isEnabled
+
+inline val View.disabled
+    get() = !enabled
+
+fun View.disable() {
+    if (this is ViewGroup) {
+        (0 until childCount).forEach { getChildAt(it).disable() }
+    }
+    isEnabled = false
+}
+
+fun View.enable() {
+    if (this is ViewGroup) {
+        (0 until childCount).forEach { getChildAt(it).enable() }
+    }
+    isEnabled = true
+}
+
+fun View.toggleEnabledState(enabled: Boolean) {
+    if (enabled) {
+        enable()
+    } else {
+        disable()
+    }
+}

common/src/main/kotlin/dev/inmo/micro_utils/common/ViewVisibility.kt

@@ -0,0 +1,35 @@
+@file:Suppress("NOTHING_TO_INLINE", "unused")
+
+package dev.inmo.micro_utils.common
+
+import android.view.View
+
+inline val View.gone
+    get() = visibility == View.GONE
+inline fun View.gone() {
+    visibility = View.GONE
+}
+
+inline val View.hidden
+    get() = visibility == View.INVISIBLE
+inline fun View.hide() {
+    visibility = View.INVISIBLE
+}
+
+inline val View.shown
+    get() = visibility == View.VISIBLE
+inline fun View.show() {
+    visibility = View.VISIBLE
+}
+
+fun View.toggleVisibility(goneOnHide: Boolean = true) {
+    if (isShown) {
+        if (goneOnHide) {
+            gone()
+        } else {
+            hide()
+        }
+    } else {
+        show()
+    }
+}

coroutines/build.gradle

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

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

@@ -19,7 +19,7 @@ fun <T> CoroutineScope.actor(
 
 inline fun <T> CoroutineScope.safeActor(
     channelCapacity: Int = Channel.UNLIMITED,
-    noinline onException: ExceptionHandler<Unit> = {},
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
     crossinline block: suspend (T) -> Unit
 ): Channel<T> = actor(
     channelCapacity

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

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.FlowCollector
+
+suspend inline operator fun <T> FlowCollector<T>.invoke(value: T) = emit(value)

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

@@ -16,7 +16,7 @@ inline fun <T> Flow<T>.subscribe(scope: CoroutineScope, noinline block: suspend
  */
 inline fun <T> Flow<T>.subscribeSafely(
     scope: CoroutineScope,
-    noinline onException: ExceptionHandler<Unit> = { throw it },
+    noinline onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
     noinline block: suspend (T) -> Unit
 ) = subscribe(scope) {
     safely(onException) {

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

@@ -1,23 +1,123 @@
 package dev.inmo.micro_utils.coroutines
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.supervisorScope
-
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
 
 typealias ExceptionHandler<T> = suspend (Throwable) -> T
+
+/**
+ * This instance will be used in all calls of [safely] where exception handler has not been passed
+ */
+var defaultSafelyExceptionHandler: ExceptionHandler<Nothing> = { throw it }
+
+/**
+ * Key for [SafelyExceptionHandler] which can be used in [CoroutineContext.get] to get current default
+ * [SafelyExceptionHandler]
+ */
+@Deprecated("This method will be useless in future major update", ReplaceWith("ContextSafelyExceptionHandlerKey", "dev.inmo.micro_utils.coroutines.ContextSafelyExceptionHandler"))
+class SafelyExceptionHandlerKey<T> : CoroutineContext.Key<SafelyExceptionHandler<T>>
+
+/**
+ * Shortcut for creating instance of [SafelyExceptionHandlerKey]
+ */
+@Suppress("NOTHING_TO_INLINE")
+@Deprecated("This method will be useless in future major update", ReplaceWith("ContextSafelyExceptionHandlerKey", "dev.inmo.micro_utils.coroutines.ContextSafelyExceptionHandler"))
+inline fun <T> safelyExceptionHandlerKey() = SafelyExceptionHandlerKey<T>()
+
+/**
+ * Wrapper for [ExceptionHandler] which can be used in [CoroutineContext] to set local (for [CoroutineContext]) default
+ * [ExceptionHandler]. To get it use [CoroutineContext.get] with key [SafelyExceptionHandlerKey]
+ *
+ * @see SafelyExceptionHandlerKey
+ * @see ExceptionHandler
+ */
+@Deprecated("This method will be useless in future major update", ReplaceWith("ContextSafelyExceptionHandler", "dev.inmo.micro_utils.coroutines.ContextSafelyExceptionHandler"))
+class SafelyExceptionHandler<T>(
+    val handler: ExceptionHandler<T>
+) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*> = safelyExceptionHandlerKey<T>()
+}
+
+/**
+ * This key can (and will) be used to get [ContextSafelyExceptionHandler] from [coroutineContext] of suspend functions
+ * and in [ContextSafelyExceptionHandler] for defining of its [CoroutineContext.Element.key]
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandler
+ */
+object ContextSafelyExceptionHandlerKey : CoroutineContext.Key<ContextSafelyExceptionHandler>
+
+/**
+ * [ExceptionHandler] wrapper which was created to make possible to use [handler] across all coroutines calls
+ *
+ * @see safelyWithContextExceptionHandler
+ * @see ContextSafelyExceptionHandlerKey
+ */
+class ContextSafelyExceptionHandler(
+    val handler: ExceptionHandler<Unit>
+) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*>
+        get() = ContextSafelyExceptionHandlerKey
+}
+
+/**
+ * @return [ContextSafelyExceptionHandler] from [coroutineContext] by key [ContextSafelyExceptionHandlerKey] if
+ * exists
+ *
+ * @see ContextSafelyExceptionHandler
+ * @see ContextSafelyExceptionHandlerKey
+ */
+suspend inline fun contextSafelyExceptionHandler() = coroutineContext[ContextSafelyExceptionHandlerKey]
+
+/**
+ * This method will set new [coroutineContext] with [ContextSafelyExceptionHandler]. In case if [coroutineContext]
+ * already contains [ContextSafelyExceptionHandler], [ContextSafelyExceptionHandler.handler] will be used BEFORE
+ * [contextExceptionHandler] in case of exception.
+ *
+ * After all, will be called [withContext] method with created [ContextSafelyExceptionHandler] and block which will call
+ * [safely] method with [safelyExceptionHandler] as onException parameter and [block] as execution block
+ */
+suspend fun <T> safelyWithContextExceptionHandler(
+    contextExceptionHandler: ExceptionHandler<Unit>,
+    safelyExceptionHandler: ExceptionHandler<T> = defaultSafelyExceptionHandler,
+    block: suspend CoroutineScope.() -> T
+): T {
+    val contextSafelyExceptionHandler = contextSafelyExceptionHandler() ?.handler ?.let { oldHandler ->
+        ContextSafelyExceptionHandler {
+            oldHandler(it)
+            contextExceptionHandler(it)
+        }
+    } ?: ContextSafelyExceptionHandler(contextExceptionHandler)
+    return withContext(contextSafelyExceptionHandler) {
+        safely(safelyExceptionHandler, block)
+    }
+}
+
 /**
  * It will run [block] inside of [supervisorScope] to avoid problems with catching of exceptions
  *
+ * Priorities of [ExceptionHandler]s:
+ *
+ * * [onException] In case if custom (will be used anyway if not [defaultSafelyExceptionHandler])
+ * * [CoroutineContext.get] with [SafelyExceptionHandlerKey] as key
+ * * [defaultSafelyExceptionHandler]
+ *
  * @param [onException] Will be called when happen exception inside of [block]. By default will throw exception - this
  * exception will be available for catching
+ *
+ * @see defaultSafelyExceptionHandler
+ * @see safelyWithoutExceptions
+ * @see safelyWithContextExceptionHandler
  */
 suspend inline fun <T> safely(
-    noinline onException: ExceptionHandler<T> = { throw it },
+    noinline onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
     noinline block: suspend CoroutineScope.() -> T
 ): T {
     return try {
         supervisorScope(block)
     } catch (e: Throwable) {
+        coroutineContext[ContextSafelyExceptionHandlerKey] ?.handler ?.invoke(e)
         onException(e)
     }
 }

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

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+
+fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T): T {
+    var throwable: Throwable? = null
+    var result: T? = null
+    val objectToSynchronize = java.lang.Object()
+    val launchCallback = {
+        launch {
+            safely(
+                {
+                    throwable = it
+                }
+            ) {
+                result = block()
+            }
+            synchronized(objectToSynchronize) {
+                objectToSynchronize.notifyAll()
+            }
+        }
+    }
+    synchronized(objectToSynchronize) {
+        launchCallback()
+        objectToSynchronize.wait()
+    }
+    throw throwable ?: return result!!
+}
+
+fun <T> launchSynchronously(block: suspend CoroutineScope.() -> T): T = CoroutineScope(Dispatchers.Default).launchSynchronously(block)

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

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

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

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LaunchSynchronouslyTest {
+    @Test
+    fun testRunInCoroutine() {
+        (0 .. 10000).forEach {
+            assertEquals(it, launchSynchronously { it })
+        }
+    }
+}

defaultAndroidSettings

@@ -1,3 +1,5 @@
+apply plugin: 'com.getkeepsafe.dexcount'
+
 android {
     compileSdkVersion "$android_compileSdkVersion".toInteger()
     buildToolsVersion "$android_buildToolsVersion"

dokka/build.gradle

@@ -2,7 +2,6 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
     id "com.android.library"
-    id "kotlin-android-extensions"
     id "org.jetbrains.dokka"
 }
 

gradle.properties

@@ -5,41 +5,40 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 android.useAndroidX=true
 android.enableJetifier=true
-org.gradle.jvmargs=-Xmx3072m
 
-kotlin_version=1.4.10
-kotlin_coroutines_version=1.4.1
+kotlin_version=1.4.21
+kotlin_coroutines_version=1.4.2
 kotlin_serialisation_core_version=1.0.1
 kotlin_exposed_version=0.28.1
 
-ktor_version=1.4.2
+ktor_version=1.5.0
 
-klockVersion=1.12.1
+klockVersion=2.0.2
 
-gradle_bintray_plugin_version=1.8.5
 github_release_plugin_version=2.2.12
 
-uuidVersion=0.2.2
+uuidVersion=0.2.3
 
 # ANDROID
 
 core_ktx_version=1.3.2
 androidx_recycler_version=1.1.0
+appcompat_version=1.2.0
 
 android_minSdkVersion=19
 android_compileSdkVersion=30
 android_buildToolsVersion=30.0.2
-dexcount_version=2.0.0-RC1
+dexcount_version=2.0.0
 junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
 
 # Dokka
 
-dokka_version=1.4.0
+dokka_version=1.4.20
 
 # Project data
 
 group=dev.inmo
-version=0.4.2
-android_code_version=6
+version=0.4.15
+android_code_version=19

gradle/wrapper/gradle-wrapper.properties

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

ktor/client/build.gradle

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

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

@@ -25,7 +25,7 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
         val producerScope = this@channelFlow
         do {
             val reconnect = try {
-                safely ({ throw it }) {
+                safely {
                     ws(correctedUrl) {
                         for (received in incoming) {
                             when (received) {
@@ -64,10 +64,11 @@ inline fun <T> HttpClient.createStandardWebsocketFlow(
 inline fun <T> HttpClient.createStandardWebsocketFlow(
     url: String,
     crossinline checkReconnection: (Throwable?) -> Boolean = { true },
-    deserializer: DeserializationStrategy<T>
+    deserializer: DeserializationStrategy<T>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
 ) = createStandardWebsocketFlow(
     url,
     checkReconnection
 ) {
-    standardKtorSerialFormat.decodeDefault(deserializer, it)
+    serialFormat.decodeDefault(deserializer, it)
 }

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

@@ -4,32 +4,61 @@ import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.get
 import io.ktor.client.request.post
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.*
 
 typealias BodyPair<T> = Pair<SerializationStrategy<T>, T>
 
+class UnifiedRequester(
+    private val client: HttpClient = HttpClient(),
+    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+) {
+    suspend fun <ResultType> uniget(
+        url: String,
+        resultDeserializer: DeserializationStrategy<ResultType>
+    ): ResultType = client.get<StandardKtorSerialInputData>(
+        url
+    ).let {
+        serialFormat.decodeDefault(resultDeserializer, it)
+    }
+
+
+    fun <T> encodeUrlQueryValue(
+        serializationStrategy: SerializationStrategy<T>,
+        value: T
+    ) = serialFormat.encodeHex(
+        serializationStrategy,
+        value
+    )
+
+    suspend fun <BodyType, ResultType> unipost(
+        url: String,
+        bodyInfo: BodyPair<BodyType>,
+        resultDeserializer: DeserializationStrategy<ResultType>
+    ) = client.post<StandardKtorSerialInputData>(url) {
+        body = serialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
+    }.let {
+        serialFormat.decodeDefault(resultDeserializer, it)
+    }
+
+    fun <T> createStandardWebsocketFlow(
+        url: String,
+        checkReconnection: (Throwable?) -> Boolean = { true },
+        deserializer: DeserializationStrategy<T>
+    ) = client.createStandardWebsocketFlow(url, checkReconnection, deserializer, serialFormat)
+}
+
+val defaultRequester = UnifiedRequester()
+
 suspend fun <ResultType> HttpClient.uniget(
     url: String,
     resultDeserializer: DeserializationStrategy<ResultType>
-) = get<StandardKtorSerialInputData>(
-    url
-).let {
-    standardKtorSerialFormat.decodeDefault(resultDeserializer, it)
-}
+) = defaultRequester.uniget(url, resultDeserializer)
 
 
-fun <T> SerializationStrategy<T>.encodeUrlQueryValue(value: T) = standardKtorSerialFormat.encodeHex(
-    this,
-    value
-)
+fun <T> SerializationStrategy<T>.encodeUrlQueryValue(value: T) = defaultRequester.encodeUrlQueryValue(this, value)
 
 suspend fun <BodyType, ResultType> HttpClient.unipost(
     url: String,
     bodyInfo: BodyPair<BodyType>,
     resultDeserializer: DeserializationStrategy<ResultType>
-) = post<StandardKtorSerialInputData>(url) {
-    body = standardKtorSerialFormat.encodeDefault(bodyInfo.first, bodyInfo.second)
-}.let {
-    standardKtorSerialFormat.decodeDefault(resultDeserializer, it)
-}
+) = defaultRequester.unipost(url, bodyInfo, resultDeserializer)

ktor/common/build.gradle

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

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

@@ -3,16 +3,28 @@ package dev.inmo.micro_utils.ktor.common
 typealias QueryParam = Pair<String, String?>
 typealias QueryParams = Map<String, String?>
 
+/**
+ * Create query part which includes key=value pairs separated with &
+ */
 val QueryParams.asUrlQuery: String
     get() = keys.joinToString("&") { "${it}${get(it) ?.let { value -> "=$value" }}" }
 
+/**
+ * Create query part which includes key=value pairs separated with &
+ */
 val List<QueryParam>.asUrlQuery: String
     get() = joinToString("&") { (key, value) -> "${key}${value ?.let { _ -> "=$value" }}" }
 
+/**
+ * Create query part which includes key=value pairs separated with & and attach to receiver
+ */
 fun String.includeQueryParams(
     queryParams: QueryParams
 ): String = "$this${if(queryParams.isNotEmpty()) "${if (contains("?")) "&" else "?"}${queryParams.asUrlQuery}" else ""}"
 
+/**
+ * Create query part which includes key=value pairs separated with & and attach to receiver
+ */
 fun String.includeQueryParams(
     queryParams: List<QueryParam>
 ): String = "$this${if (contains("?")) "&" else "?"}${queryParams.asUrlQuery}"

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

@@ -33,10 +33,11 @@ fun <T> Route.includeWebsocketHandling(
 fun <T> Route.includeWebsocketHandling(
     suburl: String,
     flow: Flow<T>,
-    serializer: SerializationStrategy<T>
+    serializer: SerializationStrategy<T>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
 ) = includeWebsocketHandling(
     suburl,
     flow
 ) {
-    standardKtorSerialFormat.encodeDefault(serializer, it)
+    serialFormat.encodeDefault(serializer, it)
 }

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

@@ -3,12 +3,87 @@ package dev.inmo.micro_utils.ktor.server
 import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.micro_utils.ktor.common.*
 import io.ktor.application.ApplicationCall
+import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.request.receive
 import io.ktor.response.respond
 import io.ktor.response.respondBytes
-import kotlinx.serialization.DeserializationStrategy
-import kotlinx.serialization.SerializationStrategy
+import io.ktor.routing.Route
+import io.ktor.util.pipeline.PipelineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.*
+
+class UnifiedRouter(
+    private val serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    private val serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) {
+    fun <T> Route.includeWebsocketHandling(
+        suburl: String,
+        flow: Flow<T>,
+        serializer: SerializationStrategy<T>
+    ) = includeWebsocketHandling(suburl, flow, serializer, serialFormat)
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.unianswer(
+        answerSerializer: SerializationStrategy<T>,
+        answer: T
+    ) {
+        call.respondBytes (
+            serialFormat.encodeDefault(answerSerializer, answer),
+            serialFormatContentType
+        )
+    }
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.uniload(
+        deserializer: DeserializationStrategy<T>
+    ) = safely {
+        serialFormat.decodeDefault(
+            deserializer,
+            call.receive()
+        )
+    }
+
+    suspend fun PipelineContext<*, ApplicationCall>.getParameterOrSendError(
+        field: String
+    ) = call.parameters[field].also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request must contains $field")
+        }
+    }
+
+    fun PipelineContext<*, ApplicationCall>.getQueryParameter(
+        field: String
+    ) = call.request.queryParameters[field]
+
+    suspend fun PipelineContext<*, ApplicationCall>.getQueryParameterOrSendError(
+        field: String
+    ) = getQueryParameter(field).also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+        }
+    }
+
+    fun <T> PipelineContext<*, ApplicationCall>.decodeUrlQueryValue(
+        field: String,
+        deserializer: DeserializationStrategy<T>
+    ) = getQueryParameter(field) ?.let {
+        serialFormat.decodeHex(
+            deserializer,
+            it
+        )
+    }
+
+    suspend fun <T> PipelineContext<*, ApplicationCall>.decodeUrlQueryValueOrSendError(
+        field: String,
+        deserializer: DeserializationStrategy<T>
+    ) = decodeUrlQueryValue(field, deserializer).also {
+        if (it == null) {
+            call.respond(HttpStatusCode.BadRequest, "Request query parameters must contains $field")
+        }
+    }
+}
+
+val defaultUnifiedRouter = UnifiedRouter()
 
 suspend fun <T> ApplicationCall.unianswer(
     answerSerializer: SerializationStrategy<T>,

mime_types/build.gradle

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

pagination/common/build.gradle

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

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

@@ -22,6 +22,12 @@ interface Pagination {
     val size: Int
 }
 
+/**
+ * Logical shortcut for comparison that page is 0
+ */
+inline val Pagination.isFirstPage
+    get() = page == 0
+
 /**
  * First number in index of objects. It can be used as offset for databases or other data sources
  */

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

@@ -0,0 +1,41 @@
+package dev.inmo.micro_utils.pagination.utils
+
+import dev.inmo.micro_utils.pagination.*
+
+class PaginatedIterator<T>(
+    pageSize: Int,
+    private val countGetter: () -> Long,
+    private val paginationResultGetter: Pagination.() -> PaginationResult<T>
+) : Iterator<T> {
+    private var pagination = FirstPagePagination(pageSize)
+    private val currentStack = mutableListOf<T>()
+    override fun hasNext(): Boolean = currentStack.isNotEmpty() || (countGetter() < pagination.lastIndexExclusive)
+
+    override fun next(): T {
+        if (currentStack.isEmpty()) {
+            val resultPagination = paginationResultGetter.invoke(pagination)
+            currentStack.addAll(resultPagination.results)
+            require(currentStack.isNotEmpty()) { "There is no elements left" }
+            pagination = resultPagination.nextPage()
+        }
+        return currentStack.removeFirst()
+    }
+}
+
+class PaginatedIterable<T>(
+    private val pageSize: Int,
+    private val countGetter: () -> Long,
+    private val paginationResultGetter: Pagination.() -> PaginationResult<T>
+) : Iterable<T> {
+    override fun iterator(): Iterator<T> = PaginatedIterator(pageSize, countGetter, paginationResultGetter)
+}
+
+/**
+ * Will make iterable using incoming [countGetter] and [paginationResultGetter]
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T> makeIterable(
+    noinline countGetter: () -> Long,
+    pageSize: Int = defaultMediumPageSize,
+    noinline paginationResultGetter: Pagination.() -> PaginationResult<T>
+): Iterable<T> = PaginatedIterable(pageSize, countGetter, paginationResultGetter)

pagination/ktor/common/build.gradle

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

publish.gradle

@@ -3,6 +3,9 @@ apply plugin: 'maven-publish'
 task javadocsJar(type: Jar) {
     classifier = 'javadoc'
 }
+task sourceJar (type : Jar) {
+    classifier = 'sources'
+}
 
 afterEvaluate {
     project.publishing.publications.all {
@@ -10,6 +13,7 @@ afterEvaluate {
         groupId "${project.group}"
         if (it.name.contains('kotlinMultiplatform')) {
             artifactId = "${project.name}"
+            artifact sourceJar
         } else {
             artifactId = "${project.name}-$name"
         }

repos/common/build.gradle

@@ -2,7 +2,6 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
     id "com.android.library"
-    id "kotlin-android-extensions"
 }
 
 apply from: "$mppProjectWithSerializationPresetPath"
@@ -18,6 +17,11 @@ kotlin {
             }
         }
 
+        jvmMain {
+            dependencies {
+                api internalProject("micro_utils.common")
+            }
+        }
         androidMain {
             dependencies {
                 api "androidx.core:core-ktx:$core_ktx_version"

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

@@ -36,6 +36,7 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
         }
     }
 }
+typealias ReadKeyValuesRepo<Key,Value> = ReadOneToManyKeyValueRepo<Key, Value>
 
 interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
@@ -53,6 +54,7 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
         add(toSet)
     }
 }
+typealias WriteKeyValuesRepo<Key,Value> = WriteOneToManyKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
     keysAndValues: List<Pair<Key, List<Value>>>
@@ -87,6 +89,7 @@ suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.set(
 ) = set(k, v.toList())
 
 interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value>
+typealias KeyValuesRepo<Key,Value> = OneToManyKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
     keysAndValues: List<Pair<Key, List<Value>>>

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

@@ -10,6 +10,7 @@ interface ReadStandardCRUDRepo<ObjectType, IdType> : Repo {
     suspend fun contains(id: IdType): Boolean
     suspend fun count(): Long
 }
+typealias ReadCRUDRepo<ObjectType, IdType> = ReadStandardCRUDRepo<ObjectType, IdType>
 
 typealias UpdatedValuePair<IdType, ValueType> = Pair<IdType, ValueType>
 val <IdType> UpdatedValuePair<IdType, *>.id
@@ -27,6 +28,7 @@ interface WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
     suspend fun update(values: List<UpdatedValuePair<IdType, InputValueType>>): List<ObjectType>
     suspend fun deleteById(ids: List<IdType>)
 }
+typealias WriteCRUDRepo<ObjectType, IdType, InputValueType> = WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
 
 suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>.create(
     vararg values: InputValueType
@@ -39,4 +41,5 @@ suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectTyp
 ) = deleteById(ids.toList())
 
 interface StandardCRUDRepo<ObjectType, IdType, InputValueType> : ReadStandardCRUDRepo<ObjectType, IdType>,
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+typealias CRUDRepo<ObjectType, IdType, InputValueType> = StandardCRUDRepo<ObjectType, IdType, InputValueType>

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

@@ -1,7 +1,6 @@
 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.*
 import kotlinx.coroutines.flow.Flow
 
 interface ReadStandardKeyValueRepo<Key, Value> : Repo {
@@ -12,6 +11,7 @@ interface ReadStandardKeyValueRepo<Key, Value> : Repo {
     suspend fun contains(key: Key): Boolean
     suspend fun count(): Long
 }
+typealias ReadKeyValueRepo<Key,Value> = ReadStandardKeyValueRepo<Key, Value>
 
 interface WriteStandardKeyValueRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
@@ -19,7 +19,9 @@ interface WriteStandardKeyValueRepo<Key, Value> : Repo {
 
     suspend fun set(toSet: Map<Key, Value>)
     suspend fun unset(toUnset: List<Key>)
+    suspend fun unsetWithValues(toUnset: List<Value>)
 }
+typealias WriteKeyValueRepo<Key,Value> = WriteStandardKeyValueRepo<Key, Value>
 
 suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
     vararg toSet: Pair<Key, Value>
@@ -33,4 +35,17 @@ suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unset(
     vararg k: Key
 ) = unset(k.toList())
 
-interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value>
+suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unsetWithValues(
+    vararg v: Value
+) = unsetWithValues(v.toList())
+
+interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value> {
+    override suspend fun unsetWithValues(toUnset: List<Value>) = toUnset.forEach { v ->
+        doWithPagination {
+            keys(v, it).also {
+                unset(it.results)
+            }
+        }
+    }
+}
+typealias KeyValueRepo<Key,Value> = StandardKeyValueRepo<Key, Value>

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

@@ -105,6 +105,10 @@ open class MapperWriteStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
             k.toOutKey()
         }
     )
+
+    override suspend fun unsetWithValues(toUnset: List<FromValue>) = to.unsetWithValues(
+        toUnset.map { it.toOutValue() }
+    )
 }
 
 @Suppress("NOTHING_TO_INLINE")

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/versions/KeyValueBasedVersionsRepoProxy.kt

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.repos.versions
+
+import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.set
+
+class KeyValueBasedVersionsRepoProxy<T>(
+    private val keyValueStore: StandardKeyValueRepo<String, Int>,
+    override val database: T
+) : StandardVersionsRepoProxy<T> {
+    override suspend fun getTableVersion(tableName: String): Int? = keyValueStore.get(tableName)
+
+    override suspend fun updateTableVersion(tableName: String, version: Int) { keyValueStore.set(tableName, version) }
+}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/versions/StandardVersionsRepo.kt

@@ -0,0 +1,36 @@
+package dev.inmo.micro_utils.repos.versions
+
+import dev.inmo.micro_utils.repos.Repo
+
+interface StandardVersionsRepoProxy<T> : Repo {
+    val database: T
+
+    suspend fun getTableVersion(tableName: String): Int?
+    suspend fun updateTableVersion(tableName: String, version: Int)
+}
+
+class StandardVersionsRepo<T>(
+    private val proxy: StandardVersionsRepoProxy<T>
+) : VersionsRepo<T> {
+    override suspend fun setTableVersion(
+        tableName: String,
+        version: Int,
+        onCreate: suspend T.() -> Unit,
+        onUpdate: suspend T.(from: Int, to: Int) -> Unit
+    ) {
+        var savedVersion = proxy.getTableVersion(tableName)
+        if (savedVersion == null) {
+            proxy.database.onCreate()
+            proxy.updateTableVersion(tableName, version)
+        } else {
+            while (savedVersion != null && savedVersion < version) {
+                val newVersion = savedVersion + 1
+
+                proxy.database.onUpdate(savedVersion, newVersion)
+
+                proxy.updateTableVersion(tableName, newVersion)
+                savedVersion = newVersion
+            }
+        }
+    }
+}

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/versions/VersionsRepo.kt

@@ -0,0 +1,31 @@
+package dev.inmo.micro_utils.repos.versions
+
+import dev.inmo.micro_utils.repos.Repo
+
+/**
+ * This interface has been created due to requirement to work with different versions of databases and make some
+ * migrations between versions
+ *
+ * @param T It is a type of database, which will be used by this repo to retrieve current table version and update it
+ */
+interface VersionsRepo<T> : Repo {
+    /**
+     * By default, instance of this interface will check that version of table with name [tableName] is less than
+     * [version] or is absent
+     *
+     * * In case if [tableName] didn't found, will be called [onCreate] and version of table will be set up to [version]
+     * * In case if [tableName] have version less than parameter [version], it will increase version one-by-one
+     * until database version will be equal to [version]
+     *
+     * @param version Current version of table
+     * @param onCreate This callback will be called in case when table have no information about table
+     * @param onUpdate This callback will be called after **iterative** changing of version. It is expected that parameter
+     * "to" will always be greater than "from"
+     */
+    suspend fun setTableVersion(
+        tableName: String,
+        version: Int,
+        onCreate: suspend T.() -> Unit = {},
+        onUpdate: suspend T.(from: Int, to: Int) -> Unit = { _, _ ->}
+    )
+}

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

@@ -0,0 +1,183 @@
+package dev.inmo.micro_utils.repos
+
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.pagination.utils.reverse
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import java.io.File
+import java.nio.file.FileSystems
+import java.nio.file.Path
+import java.nio.file.StandardWatchEventKinds.*
+
+private inline val String.isAbsolute
+    get() = startsWith(File.separator)
+
+class FileReadStandardKeyValueRepo(
+    private val folder: File
+) : ReadStandardKeyValueRepo<String, File> {
+    init {
+        folder.mkdirs()
+    }
+
+    override suspend fun get(k: String): File? {
+        val file = File(folder, k)
+        if (file.exists()) {
+            return file
+        }
+        return null
+    }
+
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<File> {
+        val count = count()
+        val resultPagination = if (reversed) pagination.reverse(count) else pagination
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndex) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
+        }
+        return filesPaths.map { File(folder, it) }.createPaginationResult(
+            resultPagination,
+            count
+        )
+    }
+
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<String> {
+        val count = count()
+        val resultPagination = if (reversed) pagination.reverse(count) else pagination
+        val filesPaths = folder.list() ?.copyOfRange(resultPagination.firstIndex, resultPagination.lastIndex) ?: return emptyPaginationResult()
+        if (reversed) {
+            filesPaths.reverse()
+        }
+        return filesPaths.toList().createPaginationResult(
+            resultPagination,
+            count
+        )
+    }
+
+    override suspend fun keys(
+        v: File,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<String> {
+        val resultPagination = if (reversed) pagination.reverse(1L) else pagination
+        return if (resultPagination.isFirstPage) {
+            val fileSubpath = v.absolutePath.removePrefix(folder.absolutePath)
+            if (fileSubpath == v.absolutePath) {
+                emptyList()
+            } else {
+                listOf(fileSubpath)
+            }
+        } else {
+            emptyList()
+        }.createPaginationResult(resultPagination, 1L)
+    }
+
+    override suspend fun contains(key: String): Boolean {
+        return File(folder, key).exists()
+    }
+
+    override suspend fun count(): Long = folder.list() ?.size ?.toLong() ?: 0L
+}
+
+/**
+ * Files watching will not correctly works on Android with version of API lower than API 26
+ */
+@Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
+class FileWriteStandardKeyValueRepo(
+    private val folder: File,
+    filesChangedProcessingScope: CoroutineScope? = null
+) : WriteStandardKeyValueRepo<String, File> {
+    private val _onNewValue = MutableSharedFlow<Pair<String, File>>()
+    override val onNewValue: Flow<Pair<String, File>> = _onNewValue.asSharedFlow()
+    private val _onValueRemoved = MutableSharedFlow<String>()
+    override val onValueRemoved: Flow<String> = _onValueRemoved.asSharedFlow()
+
+    init {
+        folder.mkdirs()
+        filesChangedProcessingScope ?.let {
+            it.launch {
+                try {
+                    val folderPath = folder.toPath()
+                    while (isActive) {
+                        val key = try {
+                            folderPath.register(FileSystems.getDefault().newWatchService(), ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE)
+                        } catch (e: Exception) {
+                            // add verbose way to show that file watching is not working
+                            return@launch
+                        }
+
+                        for (event in key.pollEvents()) {
+                            val relativeFilePath = (event.context() as? Path) ?: continue
+                            val file = relativeFilePath.toFile()
+                            val relativePath = file.toRelativeString(folder)
+
+                            when (event.kind()) {
+                                ENTRY_CREATE, ENTRY_MODIFY -> {
+                                    launch {
+                                        _onNewValue.emit(relativePath to file)
+                                    }
+                                }
+                                ENTRY_DELETE -> {
+                                    launch {
+                                        _onValueRemoved.emit(relativePath)
+                                    }
+                                }
+                            }
+                        }
+
+                        if (key.isValid || folder.exists()) {
+                            continue
+                        }
+                        break
+                    }
+                } catch (e: Throwable) {
+                    // add verbose way to notify that this functionality is disabled
+                }
+            }
+        }
+    }
+
+    override suspend fun set(toSet: Map<String, File>) {
+        supervisorScope {
+            toSet.map { (filename, fileSource) ->
+                launch {
+                    val file = File(folder, filename)
+
+                    file.delete()
+                    fileSource.copyTo(file, overwrite = true)
+                    _onNewValue.emit(filename to file)
+                }
+            }
+        }.joinAll()
+    }
+
+    override suspend fun unset(toUnset: List<String>) {
+        toUnset.forEach {
+            val file = File(folder, it)
+            if (file.exists()) {
+                file.delete()
+                _onValueRemoved.emit(it)
+            }
+        }
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<File>) {
+        val keys = toUnset.mapNotNull { v ->
+            val key = v.absolutePath.removePrefix(folder.absolutePath)
+            if (key != v.absolutePath) {
+                key
+            } else {
+                null
+            }
+        }
+        unset(keys)
+    }
+}
+
+@Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
+class FileStandardKeyValueRepo(
+    folder: File,
+    filesChangedProcessingScope: CoroutineScope? = null
+) : StandardKeyValueRepo<String, File>,
+    WriteStandardKeyValueRepo<String, File> by FileWriteStandardKeyValueRepo(folder, filesChangedProcessingScope),
+    ReadStandardKeyValueRepo<String, File> by FileReadStandardKeyValueRepo(folder)

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/DatabaseCoroutineContext.kt

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.repos
 
-import kotlinx.coroutines.newSingleThreadContext
+import kotlinx.coroutines.Dispatchers
 import kotlin.coroutines.CoroutineContext
 
-val DatabaseCoroutineContext: CoroutineContext = newSingleThreadContext("db-context")
+val DatabaseCoroutineContext: CoroutineContext = Dispatchers.IO

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/DatabaseTransactions.kt

@@ -2,26 +2,68 @@ package dev.inmo.micro_utils.repos
 
 import android.database.sqlite.SQLiteDatabase
 import dev.inmo.micro_utils.coroutines.safely
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.concurrent.Executors
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
+
+private object ContextsPool {
+    private val contexts = mutableListOf<CoroutineContext>()
+    private val mutex = Mutex(locked = false)
+    private val freeContexts = mutableListOf<CoroutineContext>()
+
+    suspend fun acquireContext(): CoroutineContext {
+        return mutex.withLock {
+            freeContexts.removeFirstOrNull() ?: Executors.newSingleThreadExecutor().asCoroutineDispatcher().also {
+                contexts.add(it)
+            }
+        }
+    }
+
+    suspend fun freeContext(context: CoroutineContext) {
+        return mutex.withLock {
+            if (context in contexts && context !in freeContexts) {
+                freeContexts.add(context)
+            }
+        }
+    }
+
+    suspend fun <T> use(block: suspend (CoroutineContext) -> T): T = acquireContext().let {
+        try {
+            block(it)
+        } finally {
+            freeContext(it)
+        }
+    }
+}
+
+class TransactionContext(
+    val databaseContext: CoroutineContext
+): CoroutineContext.Element {
+    override val key: CoroutineContext.Key<TransactionContext> = TransactionContext
+
+    companion object : CoroutineContext.Key<TransactionContext>
+}
 
 suspend fun <T> SQLiteDatabase.transaction(block: suspend SQLiteDatabase.() -> T): T {
-    return withContext(DatabaseCoroutineContext) {
-        when {
-            inTransaction() -> {
-                block()
-            }
-            else -> {
-                beginTransaction()
-                safely(
-                    {
-                        endTransaction()
-                        throw it
-                    }
-                ) {
-                    block().also {
-                        setTransactionSuccessful()
-                        endTransaction()
-                    }
+    return coroutineContext[TransactionContext] ?.let {
+        withContext(it.databaseContext) {
+            block()
+        }
+    } ?: ContextsPool.use { context ->
+        withContext(TransactionContext(context) + context) {
+            beginTransaction()
+            safely(
+                {
+                    endTransaction()
+                    throw it
+                }
+            ) {
+                block().also {
+                    setTransactionSuccessful()
+                    endTransaction()
                 }
             }
         }

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/StandardSQLHelper.kt

@@ -5,25 +5,11 @@ import android.database.DatabaseErrorHandler
 import android.database.sqlite.SQLiteDatabase
 import android.database.sqlite.SQLiteOpenHelper
 import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.repos.versions.*
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
-private data class CallbackContinuationPair<T> (
-    val callback: suspend SQLiteDatabase.() -> T,
-    val continuation: Continuation<T>
-) {
-    suspend fun SQLiteDatabase.execute() {
-        safely(
-            {
-                continuation.resumeWithException(it)
-            }
-        ) {
-            continuation.resume(callback())
-        }
-    }
-}
-
 class StandardSQLHelper(
     context: Context,
     name: String,
@@ -36,6 +22,9 @@ class StandardSQLHelper(
 
         override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {}
     }
+    val versionsRepo: VersionsRepo<SQLiteOpenHelper> by lazy {
+        StandardVersionsRepo(AndroidSQLStandardVersionsRepoProxy(sqlOpenHelper))
+    }
 
     suspend fun <T> writableTransaction(block: suspend SQLiteDatabase.() -> T): T = sqlOpenHelper.writableTransaction(block)
 

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

@@ -3,20 +3,18 @@ package dev.inmo.micro_utils.repos.crud
 import android.content.ContentValues
 import dev.inmo.micro_utils.common.mapNotNullA
 import dev.inmo.micro_utils.repos.*
-import kotlinx.coroutines.channels.BroadcastChannel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.*
 
 abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType>(
     helper: StandardSQLHelper
 ) : WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>,
     AbstractAndroidCRUDRepo<ObjectType, IdType>(helper) {
-    protected val newObjectsChannel = BroadcastChannel<ObjectType>(64)
-    protected val updateObjectsChannel = BroadcastChannel<ObjectType>(64)
-    protected val deleteObjectsIdsChannel = BroadcastChannel<IdType>(64)
-    override val newObjectsFlow: Flow<ObjectType> = newObjectsChannel.asFlow()
-    override val updatedObjectsFlow: Flow<ObjectType> = updateObjectsChannel.asFlow()
-    override val deletedObjectsIdsFlow: Flow<IdType> = deleteObjectsIdsChannel.asFlow()
+    protected val newObjectsChannel = MutableSharedFlow<ObjectType>(64)
+    protected val updateObjectsChannel = MutableSharedFlow<ObjectType>(64)
+    protected val deleteObjectsIdsChannel = MutableSharedFlow<IdType>(64)
+    override val newObjectsFlow: Flow<ObjectType> = newObjectsChannel.asSharedFlow()
+    override val updatedObjectsFlow: Flow<ObjectType> = updateObjectsChannel.asSharedFlow()
+    override val deletedObjectsIdsFlow: Flow<IdType> = deleteObjectsIdsChannel.asSharedFlow()
 
     protected abstract suspend fun InputValueType.asContentValues(id: IdType? = null): ContentValues
 
@@ -42,7 +40,7 @@ abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType
             }
         }.also {
             it.forEach {
-                newObjectsChannel.send(it)
+                newObjectsChannel.emit(it)
             }
         }
     }
@@ -59,7 +57,7 @@ abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType
             }
         }
         deleted.forEach {
-            deleteObjectsIdsChannel.send(it)
+            deleteObjectsIdsChannel.emit(it)
         }
     }
 
@@ -76,7 +74,7 @@ abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType
             }
         }
         return getById(id) ?.also {
-            updateObjectsChannel.send(it)
+            updateObjectsChannel.emit(it)
         }
     }
 
@@ -95,7 +93,7 @@ abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType
             getById(it.first)
         }.also {
             it.forEach {
-                updateObjectsChannel.send(it)
+                updateObjectsChannel.emit(it)
             }
         }
     }

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

@@ -8,10 +8,7 @@ import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import dev.inmo.micro_utils.repos.StandardKeyValueRepo
-import kotlinx.coroutines.channels.BroadcastChannel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.*
 
 private val cache = HashMap<String, KeyValueStore<*>>()
 
@@ -37,11 +34,11 @@ class KeyValueStore<T : Any> internal constructor (
         null
     }
 
-    private val onNewValueChannel = BroadcastChannel<Pair<String, T>>(Channel.BUFFERED)
-    private val onValueRemovedChannel = BroadcastChannel<String>(Channel.BUFFERED)
+    private val onNewValueChannel = MutableSharedFlow<Pair<String, T>>()
+    private val _onValueRemovedFlow = MutableSharedFlow<String>()
 
-    override val onNewValue: Flow<Pair<String, T>> = onNewValueChannel.asFlow()
-    override val onValueRemoved: Flow<String> = onValueRemovedChannel.asFlow()
+    override val onNewValue: Flow<Pair<String, T>> = onNewValueChannel.asSharedFlow()
+    override val onValueRemoved: Flow<String> = _onValueRemovedFlow.asSharedFlow()
 
     init {
         cachedData ?.let {
@@ -131,7 +128,7 @@ class KeyValueStore<T : Any> internal constructor (
             }
         }
         toSet.forEach { (k, v) ->
-            onNewValueChannel.send(k to v)
+            onNewValueChannel.emit(k to v)
         }
     }
 
@@ -139,6 +136,18 @@ class KeyValueStore<T : Any> internal constructor (
         sharedPreferences.edit {
             toUnset.forEach { remove(it) }
         }
-        toUnset.forEach { onValueRemovedChannel.send(it) }
+        toUnset.forEach { _onValueRemovedFlow.emit(it) }
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<T>) {
+        val keysToRemove = sharedPreferences.all.mapNotNull { if (it.value in toUnset) it.key else null }
+        sharedPreferences.edit {
+            keysToRemove.map {
+                remove(it)
+            }
+        }
+        keysToRemove.forEach {
+            _onValueRemovedFlow.emit(it)
+        }
     }
 }

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/versions/AndroidSQLStandardVersionsRepoProxy.kt

@@ -0,0 +1,63 @@
+package dev.inmo.micro_utils.repos.versions
+
+import android.database.sqlite.SQLiteOpenHelper
+import androidx.core.content.contentValuesOf
+import dev.inmo.micro_utils.repos.*
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Will create [VersionsRepo] based on [SQLiteOpenHelper] with table inside of [database]
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun versionsRepo(database: SQLiteOpenHelper): VersionsRepo<SQLiteOpenHelper> = StandardVersionsRepo(
+    AndroidSQLStandardVersionsRepoProxy(database)
+)
+
+class AndroidSQLStandardVersionsRepoProxy(
+    override val database: SQLiteOpenHelper
+) : StandardVersionsRepoProxy<SQLiteOpenHelper> {
+    private val tableName: String = "AndroidSQLStandardVersionsRepo"
+    private val tableNameColumnName = "tableName"
+    private val tableVersionColumnName = "version"
+
+    init {
+        runBlocking(DatabaseCoroutineContext) {
+            database.writableTransaction {
+                createTable(
+                    tableName,
+                    tableNameColumnName to ColumnType.Text.NOT_NULLABLE,
+                    tableVersionColumnName to ColumnType.Numeric.INTEGER()
+                )
+            }
+        }
+    }
+
+    override suspend fun getTableVersion(tableName: String): Int? = database.writableTransaction {
+        select(
+            this@AndroidSQLStandardVersionsRepoProxy.tableName,
+            selection = "$tableNameColumnName=?",
+            selectionArgs = arrayOf(tableName),
+            limit = limitClause(1)
+        ).use {
+            if (it.moveToFirst()) {
+                it.getInt(tableVersionColumnName)
+            } else {
+                null
+            }
+        }
+    }
+
+    override suspend fun updateTableVersion(tableName: String, version: Int) {
+        database.writableTransaction {
+            val updated = update(
+                this@AndroidSQLStandardVersionsRepoProxy.tableName,
+                contentValuesOf(tableVersionColumnName to version),
+                "$tableNameColumnName=?",
+                arrayOf(tableName)
+            ) > 0
+            if (!updated) {
+                insert(this@AndroidSQLStandardVersionsRepoProxy.tableName, null, contentValuesOf(tableNameColumnName to tableName, tableVersionColumnName to version))
+            }
+        }
+    }
+}

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/versions/AndroidSharedPreferencesStandardVersionsRepoProxy.kt

@@ -0,0 +1,49 @@
+@file:Suppress("NOTHING_TO_INLINE")
+
+package dev.inmo.micro_utils.repos.versions
+
+import android.content.Context
+import android.database.sqlite.SQLiteOpenHelper
+import androidx.core.content.contentValuesOf
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.keyvalue.keyValueStore
+import kotlinx.coroutines.runBlocking
+
+/**
+ * Will create [VersionsRepo] based on [T], but versions will be stored in [StandardKeyValueRepo]
+ *
+ * @receiver Will be used to create [KeyValueBasedVersionsRepoProxy] via [keyValueStore] and pass it to [StandardVersionsRepo]
+ *
+ * @see [KeyValueBasedVersionsRepoProxy]
+ * @see [keyValueStore]
+ */
+inline fun <T> Context.versionsKeyValueRepo(
+    database: T
+): VersionsRepo<T> = StandardVersionsRepo(
+    KeyValueBasedVersionsRepoProxy(
+        keyValueStore("SPVersionsRepo"),
+        database
+    )
+)
+/**
+ * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [StandardKeyValueRepo]
+ *
+ * @receiver Will be used to create [StandardKeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
+ *
+ * @see [keyValueStore]
+ */
+inline fun Context.versionsKeyValueRepoForSQL(
+    database: SQLiteOpenHelper
+) = versionsKeyValueRepo(database)
+
+/**
+ * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [StandardKeyValueRepo]
+ *
+ * @param context Will be used to create [StandardKeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
+ *
+ * @see [keyValueStore]
+ */
+inline fun versionsRepo(
+    context: Context,
+    database: SQLiteOpenHelper
+) = context.versionsKeyValueRepoForSQL(database)

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

@@ -2,7 +2,6 @@ package dev.inmo.micro_utils.repos.exposed
 
 import dev.inmo.micro_utils.repos.UpdatedValuePair
 import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
-import kotlinx.coroutines.channels.BroadcastChannel
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.statements.InsertStatement
@@ -25,8 +24,10 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override val updatedObjectsFlow: Flow<ObjectType> = updateObjectsChannel.asSharedFlow()
     override val deletedObjectsIdsFlow: Flow<IdType> = deleteObjectsIdsChannel.asSharedFlow()
 
+    @Deprecated("Will be removed in near major update. Override open fun with the same name instead")
     abstract val InsertStatement<Number>.asObject: ObjectType
-    abstract val selectByIds: SqlExpressionBuilder.(List<out IdType>) -> Op<Boolean>
+    protected open fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType = asObject
+    abstract val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
 
     protected abstract fun insert(value: InputValueType, it: InsertStatement<Number>)
     protected abstract fun update(id: IdType, value: InputValueType, it: UpdateStatement)
@@ -34,7 +35,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     protected open suspend fun onBeforeCreate(value: List<InputValueType>) {}
     private fun createWithoutNotification(value: InputValueType): ObjectType {
         return transaction(database) {
-            insert { insert(value, it) }.asObject
+            insert { insert(value, it) }.asObject(value)
         }
     }
 
@@ -42,10 +43,8 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
         onBeforeCreate(values)
         return transaction(db = database) {
             values.map { value -> createWithoutNotification(value) }
-        }.also {
-            it.forEach {
-                newObjectsChannel.emit(it)
-            }
+        }.onEach {
+            newObjectsChannel.emit(it)
         }
     }
 
@@ -83,13 +82,9 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
         return (
             transaction(db = database) {
                 values.map { (id, value) -> updateWithoutNotification(id, value) }
-            }.filter {
-                it != null
-            } as List<ObjectType>
-        ).also {
-            it.forEach {
-                updateObjectsChannel.emit(it)
-            }
+            }.filterNotNull()
+        ).onEach {
+            updateObjectsChannel.emit(it)
         }
     }
     protected open suspend fun onBeforeDelete(ids: List<IdType>) {}

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

@@ -60,4 +60,16 @@ open class ExposedKeyValueRepo<Key, Value>(
             _onValueRemoved.emit(it)
         }
     }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) {
+        transaction(database) {
+            toUnset.flatMap {
+                val keys = select { valueColumn.eq(it) }.mapNotNull { it[keyColumn] }
+                deleteWhere { keyColumn.inList(keys) }
+                keys
+            }
+        }.distinct().forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
 }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/versions/ExposedStandardVersionsRepoProxy.kt

@@ -0,0 +1,48 @@
+package dev.inmo.micro_utils.repos.exposed.versions
+
+import dev.inmo.micro_utils.repos.exposed.ExposedRepo
+import dev.inmo.micro_utils.repos.exposed.initTable
+import dev.inmo.micro_utils.repos.versions.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.transactions.transaction
+
+/**
+ * Use this method to create [StandardVersionsRepo] based on [Database] with [ExposedStandardVersionsRepoProxy] as
+ * [StandardVersionsRepoProxy]
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun versionsRepo(database: Database): VersionsRepo<Database> = StandardVersionsRepo(
+    ExposedStandardVersionsRepoProxy(database)
+)
+
+class ExposedStandardVersionsRepoProxy(
+    override val database: Database
+) : StandardVersionsRepoProxy<Database>, Table("ExposedVersionsProxy"), ExposedRepo {
+    private val tableNameColumn = text("tableName")
+    private val tableVersionColumn = integer("tableName")
+
+    init {
+        initTable()
+    }
+
+    override suspend fun getTableVersion(tableName: String): Int? = transaction(database) {
+        select { tableNameColumn.eq(tableName) }.limit(1).firstOrNull() ?.getOrNull(tableVersionColumn)
+    }
+
+    override suspend fun updateTableVersion(tableName: String, version: Int) {
+        transaction(database) {
+            val updated = update(
+                { tableNameColumn.eq(tableName) }
+            ) {
+                it[tableVersionColumn] = version
+            } > 0
+            if (!updated) {
+                insert {
+                    it[tableNameColumn] = tableName
+                    it[tableVersionColumn] = version
+                }
+            }
+        }
+    }
+
+}

repos/inmemory/build.gradle

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

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

@@ -76,6 +76,15 @@ class WriteMapKeyValueRepo<Key, Value>(
             map.remove(k) ?.also { _ -> _onValueRemoved.emit(k) }
         }
     }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) {
+        map.forEach {
+            if (it.value in toUnset) {
+                map.remove(it.key)
+                _onValueRemoved.emit(it.key)
+            }
+        }
+    }
 }
 
 class MapKeyValueRepo<Key, Value>(

repos/ktor/client/build.gradle

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

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

@@ -1,8 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.client.*
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
@@ -12,41 +11,52 @@ import kotlinx.serialization.builtins.serializer
 
 class KtorReadStandardCrudRepo<ObjectType, IdType> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val objectsSerializer: KSerializer<ObjectType>,
     private val objectsSerializerNullable: KSerializer<ObjectType?>,
     private val idsSerializer: KSerializer<IdType>
 ) : ReadStandardCRUDRepo<ObjectType, IdType> {
     private val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
 
-    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsSerializerNullable: KSerializer<ObjectType?>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), objectsSerializer, objectsSerializerNullable, idsSerializer
+    )
+
+    override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = unifiedRequester.uniget(
         buildStandardUrl(baseUrl, getByPaginationRouting, pagination.asUrlQueryParts),
         paginationResultSerializer
     )
 
-    override suspend fun getById(id: IdType): ObjectType? = client.uniget(
+    override suspend fun getById(id: IdType): ObjectType? = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getByIdRouting,
             mapOf(
-                "id" to idsSerializer.encodeUrlQueryValue(id)
+                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
             )
         ),
         objectsSerializerNullable
     )
 
-    override suspend fun contains(id: IdType): Boolean = client.uniget(
+    override suspend fun contains(id: IdType): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsRouting,
             mapOf(
-                "id" to idsSerializer.encodeUrlQueryValue(id)
+                "id" to unifiedRequester.encodeUrlQueryValue(idsSerializer, id)
             )
         ),
         Boolean.serializer()
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRouting

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

@@ -1,5 +1,8 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
@@ -7,7 +10,7 @@ import kotlinx.serialization.KSerializer
 class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient,
+    unifiedRequester: UnifiedRequester,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
@@ -15,16 +18,29 @@ class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
 ) : StandardCRUDRepo<ObjectType, IdType, InputValue>,
     ReadStandardCRUDRepo<ObjectType, IdType> by KtorReadStandardCrudRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         objectsSerializer,
         objectsNullableSerializer,
         idsSerializer
     ),
     WriteStandardCRUDRepo<ObjectType, IdType, InputValue> by KtorWriteStandardCrudRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         objectsSerializer,
         objectsNullableSerializer,
         inputsSerializer,
         idsSerializer
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsNullableSerializer: KSerializer<ObjectType?>,
+        inputsSerializer: KSerializer<InputValue>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this(
+        baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer
     )
+}

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

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.crud
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.UpdatedValuePair
 import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
@@ -12,7 +12,7 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val objectsSerializer: KSerializer<ObjectType>,
     private val objectsNullableSerializer: KSerializer<ObjectType?>,
     private val inputsSerializer: KSerializer<InputValue>,
@@ -27,39 +27,51 @@ class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     )
     private val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
 
-    override val newObjectsFlow: Flow<ObjectType> = client.createStandardWebsocketFlow(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        objectsSerializer: KSerializer<ObjectType>,
+        objectsSerializerNullable: KSerializer<ObjectType?>,
+        inputsSerializer: KSerializer<InputValue>,
+        idsSerializer: KSerializer<IdType>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), objectsSerializer, objectsSerializerNullable, inputsSerializer, idsSerializer
+    )
+
+    override val newObjectsFlow: Flow<ObjectType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, newObjectsFlowRouting),
         deserializer = objectsSerializer
     )
-    override val updatedObjectsFlow: Flow<ObjectType> = client.createStandardWebsocketFlow(
+    override val updatedObjectsFlow: Flow<ObjectType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, updatedObjectsFlowRouting),
         deserializer = objectsSerializer
     )
-    override val deletedObjectsIdsFlow: Flow<IdType> = client.createStandardWebsocketFlow(
+    override val deletedObjectsIdsFlow: Flow<IdType> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, deletedObjectsIdsFlowRouting),
         deserializer = idsSerializer
     )
 
 
-    override suspend fun create(values: List<InputValue>): List<ObjectType> = client.unipost(
+    override suspend fun create(values: List<InputValue>): List<ObjectType> = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, createRouting),
         BodyPair(listInputSerializer, values),
         listObjectsSerializer
     )
 
-    override suspend fun update(id: IdType, value: InputValue): ObjectType? = client.unipost(
+    override suspend fun update(id: IdType, value: InputValue): ObjectType? = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, updateRouting),
         BodyPair(inputUpdateSerializer, id to value),
         objectsNullableSerializer
     )
 
-    override suspend fun update(values: List<UpdatedValuePair<IdType, InputValue>>): List<ObjectType> = client.unipost(
+    override suspend fun update(values: List<UpdatedValuePair<IdType, InputValue>>): List<ObjectType> = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, updateManyRouting),
         BodyPair(listInputUpdateSerializer, values),
         listObjectsSerializer
     )
 
-    override suspend fun deleteById(ids: List<IdType>) = client.unipost(
+    override suspend fun deleteById(ids: List<IdType>) = unifiedRequester.unipost(
         buildStandardUrl(baseUrl, deleteByIdRouting),
         BodyPair(listIdsSerializer, ids),
         Unit.serializer()

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepo.kt

@@ -1,80 +1,90 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.client.*
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import io.ktor.client.HttpClient
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
 class KtorReadStandardKeyValueRepo<Key, Value> (
-    private var baseUrl: String,
-    private var client: HttpClient = HttpClient(),
-    private var keySerializer: KSerializer<Key>,
-    private var valueSerializer: KSerializer<Value>,
-    private var valueNullableSerializer: KSerializer<Value?>,
+    private val baseUrl: String,
+    private val unifiedRequester: UnifiedRequester,
+    private val keySerializer: KSerializer<Key>,
+    private val valueSerializer: KSerializer<Value>,
+    private val valueNullableSerializer: KSerializer<Value?>
 ) : ReadStandardKeyValueRepo<Key, Value> {
-    override suspend fun get(k: Key): Value? = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        valueNullableSerializer: KSerializer<Value?>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer, valueNullableSerializer
+    )
+
+    override suspend fun get(k: Key): Value? = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k)
             )
         ),
         valueNullableSerializer
     )
 
-    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = client.uniget(
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             valuesRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(valueSerializer)
     )
 
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(keySerializer)
     )
 
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         PaginationResult.serializer(keySerializer)
     )
 
-    override suspend fun contains(key: Key): Boolean = client.uniget(
+    override suspend fun contains(key: Key): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(key)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, key)
             ),
         ),
         Boolean.serializer(),
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRoute,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorStandartKeyValueRepo.kt

@@ -1,27 +1,41 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.*
 
+@Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
 class KtorStandartKeyValueRepo<K, V> (
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient = HttpClient(),
+    unifiedRequester: UnifiedRequester,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>
 ) : StandardKeyValueRepo<K, V>,
     ReadStandardKeyValueRepo<K, V> by KtorReadStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
         valueNullableSerializer
     ),
     WriteStandardKeyValueRepo<K, V> by KtorWriteStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer
-    )
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient = HttpClient(),
+        keySerializer: KSerializer<K>,
+        valueSerializer: KSerializer<V>,
+        valueNullableSerializer: KSerializer<V?>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this(baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer, valueNullableSerializer)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteStandardKeyValueRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.key_value
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
@@ -11,23 +11,35 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteStandardKeyValueRepo<K, V> (
     private var baseUrl: String,
-    private var client: HttpClient = HttpClient(),
+    private var unifiedRequester: UnifiedRequester,
     private var keySerializer: KSerializer<K>,
     private var valueSerializer: KSerializer<V>,
 ) : WriteStandardKeyValueRepo<K, V> {
     private val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
     private val keysListSerializer = ListSerializer(keySerializer)
-    override val onNewValue: Flow<Pair<K, V>> = client.createStandardWebsocketFlow(
+    private val valuesListSerializer = ListSerializer(valueSerializer)
+
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<K>,
+        valueSerializer: KSerializer<V>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer
+    )
+
+    override val onNewValue: Flow<Pair<K, V>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = PairSerializer(keySerializer, valueSerializer)
     )
 
-    override val onValueRemoved: Flow<K> = client.createStandardWebsocketFlow(
+    override val onValueRemoved: Flow<K> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onValueRemovedRoute),
         deserializer = keySerializer
     )
 
-    override suspend fun set(toSet: Map<K, V>) = client.unipost(
+    override suspend fun set(toSet: Map<K, V>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             setRoute
@@ -36,7 +48,7 @@ class KtorWriteStandardKeyValueRepo<K, V> (
         Unit.serializer()
     )
 
-    override suspend fun unset(toUnset: List<K>) = client.unipost(
+    override suspend fun unset(toUnset: List<K>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             unsetRoute,
@@ -44,4 +56,13 @@ class KtorWriteStandardKeyValueRepo<K, V> (
         BodyPair(keysListSerializer, toUnset),
         Unit.serializer()
     )
+
+    override suspend fun unsetWithValues(toUnset: List<V>) = unifiedRequester.unipost(
+        buildStandardUrl(
+            baseUrl,
+            unsetWithValuesRoute,
+        ),
+        BodyPair(valuesListSerializer, toUnset),
+        Unit.serializer()
+    )
 }

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorOneToManyKeyValueRepo.kt

@@ -1,5 +1,8 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
+import dev.inmo.micro_utils.ktor.client.UnifiedRequester
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
@@ -7,19 +10,28 @@ import kotlinx.serialization.KSerializer
 class KtorOneToManyKeyValueRepo<Key, Value>(
     baseUrl: String,
     baseSubpart: String,
-    client: HttpClient,
+    unifiedRequester: UnifiedRequester,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
 ) : OneToManyKeyValueRepo<Key, Value>,
     ReadOneToManyKeyValueRepo<Key, Value> by KtorReadOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
     ),
     WriteOneToManyKeyValueRepo<Key, Value> by KtorWriteOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
-        client,
+        unifiedRequester,
         keySerializer,
         valueSerializer,
-    )
+    ) {
+    constructor(
+        baseUrl: String,
+        baseSubpart: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer)
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorReadOneToManyKeyValueRepo.kt

@@ -1,8 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
-import dev.inmo.micro_utils.ktor.client.encodeUrlQueryValue
-import dev.inmo.micro_utils.ktor.client.uniget
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.client.*
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.keyParameterName
@@ -15,81 +14,89 @@ import kotlinx.serialization.builtins.serializer
 
 class KtorReadOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
-    private val valueSerializer: KSerializer<Value>,
+    private val valueSerializer: KSerializer<Value>
 ) : ReadOneToManyKeyValueRepo<Key, Value> {
     private val paginationValueResultSerializer = PaginationResult.serializer(valueSerializer)
     private val paginationKeyResultSerializer = PaginationResult.serializer(keySerializer)
 
-    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> = client.uniget(
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer)
+
+    override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             getRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationValueResultSerializer
     )
 
-    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationKeyResultSerializer
     )
 
-    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = client.uniget(
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             keysRoute,
             mapOf(
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
-                reversedParameterName to Boolean.serializer().encodeUrlQueryValue(reversed)
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
+                reversedParameterName to unifiedRequester.encodeUrlQueryValue(Boolean.serializer(), reversed)
             ) + pagination.asUrlQueryParts
         ),
         paginationKeyResultSerializer
     )
 
-    override suspend fun contains(k: Key): Boolean = client.uniget(
+    override suspend fun contains(k: Key): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsByKeyRoute,
-            mapOf(keyParameterName to keySerializer.encodeUrlQueryValue(k))
+            mapOf(keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k))
         ),
         Boolean.serializer()
     )
 
-    override suspend fun contains(k: Key, v: Value): Boolean = client.uniget(
+    override suspend fun contains(k: Key, v: Value): Boolean = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             containsByKeyValueRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k),
-                valueParameterName to valueSerializer.encodeUrlQueryValue(v),
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k),
+                valueParameterName to unifiedRequester.encodeUrlQueryValue(valueSerializer, v),
             )
         ),
         Boolean.serializer()
     )
 
-    override suspend fun count(k: Key): Long = client.uniget(
+    override suspend fun count(k: Key): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countByKeyRoute,
             mapOf(
-                keyParameterName to keySerializer.encodeUrlQueryValue(k)
+                keyParameterName to unifiedRequester.encodeUrlQueryValue(keySerializer, k)
             )
         ),
         Long.serializer()
     )
 
-    override suspend fun count(): Long = client.uniget(
+    override suspend fun count(): Long = unifiedRequester.uniget(
         buildStandardUrl(
             baseUrl,
             countRoute,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteOneToManyKeyValueRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
 import dev.inmo.micro_utils.ktor.client.*
-import dev.inmo.micro_utils.ktor.common.buildStandardUrl
+import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
@@ -11,26 +11,37 @@ import kotlinx.serialization.builtins.*
 
 class KtorWriteOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
-    private val client: HttpClient = HttpClient(),
+    private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
     private val valueSerializer: KSerializer<Value>
 ) : WriteOneToManyKeyValueRepo<Key, Value> {
     private val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
     private val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
-    override val onNewValue: Flow<Pair<Key, Value>> = client.createStandardWebsocketFlow(
+
+    constructor(
+        baseUrl: String,
+        client: HttpClient,
+        keySerializer: KSerializer<Key>,
+        valueSerializer: KSerializer<Value>,
+        serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
+    ) : this (
+        baseUrl, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer
+    )
+
+    override val onNewValue: Flow<Pair<Key, Value>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onNewValueRoute),
         deserializer = keyValueSerializer
     )
-    override val onValueRemoved: Flow<Pair<Key, Value>> = client.createStandardWebsocketFlow(
+    override val onValueRemoved: Flow<Pair<Key, Value>> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onValueRemovedRoute),
         deserializer = keyValueSerializer
     )
-    override val onDataCleared: Flow<Key> = client.createStandardWebsocketFlow(
+    override val onDataCleared: Flow<Key> = unifiedRequester.createStandardWebsocketFlow(
         buildStandardUrl(baseUrl, onDataClearedRoute),
         deserializer = keySerializer
     )
 
-    override suspend fun remove(toRemove: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             removeRoute,
@@ -39,7 +50,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         Unit.serializer(),
     )
 
-    override suspend fun add(toAdd: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun add(toAdd: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             addRoute,
@@ -47,7 +58,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         BodyPair(keyValueMapSerializer, toAdd),
         Unit.serializer(),
     )
-    override suspend fun clear(k: Key) = client.unipost(
+    override suspend fun clear(k: Key) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             clearRoute,
@@ -56,7 +67,7 @@ class KtorWriteOneToManyKeyValueRepo<Key, Value> (
         Unit.serializer(),
     )
 
-    override suspend fun set(toSet: Map<Key, List<Value>>) = client.unipost(
+    override suspend fun set(toSet: Map<Key, List<Value>>) = unifiedRequester.unipost(
         buildStandardUrl(
             baseUrl,
             setRoute,

repos/ktor/common/build.gradle

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

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

@@ -9,4 +9,5 @@ const val countRoute = "count"
 const val onNewValueRoute = "onNewValue"
 const val onValueRemovedRoute = "onValueRemoved"
 const val setRoute = "set"
-const val unsetRoute = "unset"
+const val unsetRoute = "unset"
+const val unsetWithValuesRoute = "unsetWithValues"

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

@@ -1,12 +1,14 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
-import dev.inmo.micro_utils.ktor.server.decodeUrlQueryValueOrSendError
-import dev.inmo.micro_utils.ktor.server.unianswer
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
 import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -16,47 +18,65 @@ fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
     originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
 
     get(getByPaginationRouting) {
-        val pagination = call.request.queryParameters.extractPagination
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
 
-        call.unianswer(
-            paginationResultSerializer,
-            originalRepo.getByPagination(pagination)
-        )
+            unianswer(
+                paginationResultSerializer,
+                originalRepo.getByPagination(pagination)
+            )
+        }
     }
 
     get(getByIdRouting) {
-        val id = call.decodeUrlQueryValueOrSendError(
-            "id",
-            idsSerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val id = decodeUrlQueryValueOrSendError(
+                "id",
+                idsSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            objectsNullableSerializer,
-            originalRepo.getById(id)
-        )
+            unianswer(
+                objectsNullableSerializer,
+                originalRepo.getById(id)
+            )
+        }
     }
 
     get(containsRouting) {
-        val id = call.decodeUrlQueryValueOrSendError(
-            "id",
-            idsSerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val id = decodeUrlQueryValueOrSendError(
+                "id",
+                idsSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(id)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(id)
+            )
+        }
     }
 
     get(countRouting) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
 }
+
+inline fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
+    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

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

@@ -1,6 +1,11 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
 import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
@@ -11,10 +16,24 @@ fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
-        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer)
-        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer)
+        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, unifiedRouter)
+        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, unifiedRouter)
     }
 }
+
+fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureStandardCrudRepoRoutes(
+    baseSubpart, originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

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

@@ -1,9 +1,12 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
@@ -14,7 +17,8 @@ fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
-    idsSerializer: KSerializer<IdType>
+    idsSerializer: KSerializer<IdType>,
+    unifiedRouter: UnifiedRouter
 ) {
     val listObjectsSerializer = ListSerializer(objectsSerializer)
     val listInputSerializer = ListSerializer(inputsSerializer)
@@ -25,58 +29,80 @@ fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
     )
     val listInputUpdateSerializer = ListSerializer(inputUpdateSerializer)
 
-    includeWebsocketHandling(
-        newObjectsFlowRouting,
-        originalRepo.newObjectsFlow,
-        objectsSerializer
-    )
-    includeWebsocketHandling(
-        updatedObjectsFlowRouting,
-        originalRepo.updatedObjectsFlow,
-        objectsSerializer
-    )
-    includeWebsocketHandling(
-        deletedObjectsIdsFlowRouting,
-        originalRepo.deletedObjectsIdsFlow,
-        idsSerializer
-    )
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            newObjectsFlowRouting,
+            originalRepo.newObjectsFlow,
+            objectsSerializer
+        )
+        includeWebsocketHandling(
+            updatedObjectsFlowRouting,
+            originalRepo.updatedObjectsFlow,
+            objectsSerializer
+        )
+        includeWebsocketHandling(
+            deletedObjectsIdsFlowRouting,
+            originalRepo.deletedObjectsIdsFlow,
+            idsSerializer
+        )
+    }
 
     post(createRouting) {
-        call.unianswer(
-            listObjectsSerializer,
-            originalRepo.create(
-                call.uniload(listInputSerializer)
+        unifiedRouter.apply {
+            unianswer(
+                listObjectsSerializer,
+                originalRepo.create(
+                    uniload(listInputSerializer)
+                )
             )
-        )
+        }
     }
 
     post(updateRouting) {
-        val (id, input) = call.uniload(inputUpdateSerializer)
-        call.unianswer(
-            objectsNullableSerializer,
-            originalRepo.update(
-                id, input
+        unifiedRouter.apply {
+            val (id, input) = uniload(inputUpdateSerializer)
+            unianswer(
+                objectsNullableSerializer,
+                originalRepo.update(
+                    id, input
+                )
             )
-        )
+        }
     }
 
     post(updateManyRouting) {
-        val updates = call.uniload(listInputUpdateSerializer)
-        call.unianswer(
-            listObjectsSerializer,
-            originalRepo.update(
-                updates
+        unifiedRouter.apply {
+            val updates = uniload(listInputUpdateSerializer)
+            unianswer(
+                listObjectsSerializer,
+                originalRepo.update(
+                    updates
+                )
             )
-        )
+        }
     }
 
     post(deleteByIdRouting) {
-        val ids = call.uniload(listIdsSerializer)
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.deleteById(
-                ids
+        unifiedRouter.apply {
+            val ids = uniload(listIdsSerializer)
+            unianswer(
+                Unit.serializer(),
+                originalRepo.deleteById(
+                    ids
+                )
             )
-        )
+        }
     }
 }
+
+fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
+    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>,
+    objectsSerializer: KSerializer<ObjectType>,
+    objectsNullableSerializer: KSerializer<ObjectType?>,
+    inputsSerializer: KSerializer<InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureWriteStandardCrudRepoRoutes(
+    originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartKeyValueRepo.kt

@@ -1,16 +1,22 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
 import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
 
-fun <K, V> Route.configureStandartKeyValueRepoRoutes(
+fun <K, V> Route.configureStandardKeyValueRepoRoutes(
     baseSubpart: String,
     originalRepo: StandardKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
         configureReadStandartKeyValueRepoRoutes(
@@ -18,11 +24,23 @@ fun <K, V> Route.configureStandartKeyValueRepoRoutes(
             keySerializer,
             valueSerializer,
             valueNullableSerializer,
+            unifiedRouter
         )
-        configureWriteStandartKeyValueRepoRoutes(
+        configureWriteStandardKeyValueRepoRoutes(
             originalRepo,
             keySerializer,
             valueSerializer,
+            unifiedRouter
         )
     }
-}
+}
+
+fun <K, V> Route.configureStandartKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: StandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureStandardKeyValueRepoRoutes(baseSubpart, originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartReadKeyValueRepo.kt

@@ -1,5 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
@@ -7,6 +9,7 @@ import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -17,62 +20,84 @@ fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
+    unifiedRouter: UnifiedRouter
 ) {
     get(getRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            valueNullableSerializer,
-            originalRepo.get(key)
-        )
+            unianswer(
+                valueNullableSerializer,
+                originalRepo.get(key)
+            )
+        }
     }
 
     get(valuesRoute) {
-        val parination = call.request.queryParameters.extractPagination;
-        val reversed = call.decodeUrlQueryValueOrSendError(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: return@get
+        unifiedRouter.apply {
+            val parination = call.request.queryParameters.extractPagination;
+            val reversed = decodeUrlQueryValueOrSendError(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: return@get
 
-        call.unianswer(
-            PaginationResult.serializer(valueSerializer),
-            originalRepo.values(parination, reversed)
-        )
+            unianswer(
+                PaginationResult.serializer(valueSerializer),
+                originalRepo.values(parination, reversed)
+            )
+        }
     }
 
     get(keysRoute) {
-        val parination = call.request.queryParameters.extractPagination;
-        val reversed = call.decodeUrlQueryValueOrSendError(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: return@get
-        val value = call.decodeUrlQueryValue(valueParameterName, valueSerializer)
+        unifiedRouter.apply {
+            val parination = call.request.queryParameters.extractPagination;
+            val reversed = decodeUrlQueryValueOrSendError(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: return@get
+            val value = decodeUrlQueryValue(valueParameterName, valueSerializer)
 
-        call.unianswer(
-            PaginationResult.serializer(keySerializer),
-            value ?.let { originalRepo.keys(value, parination, reversed) } ?: originalRepo.keys(parination, reversed)
-        )
+            unianswer(
+                PaginationResult.serializer(keySerializer),
+                value?.let { originalRepo.keys(value, parination, reversed) } ?: originalRepo.keys(parination, reversed)
+            )
+        }
     }
 
     get(containsRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key)
+            )
+        }
     }
 
     get(countRoute) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
-}
+}
+
+inline fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
+    originalRepo: ReadStandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    valueNullableSerializer: KSerializer<V?>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureReadStandartKeyValueRepoRoutes(
+    originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartWriteKeyValueRepo.kt

@@ -1,44 +1,70 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
+fun <K, V> Route.configureWriteStandardKeyValueRepoRoutes (
+    originalRepo: WriteStandardKeyValueRepo<K, V>,
+    keySerializer: KSerializer<K>,
+    valueSerializer: KSerializer<V>,
+    unifiedRouter: UnifiedRouter
+) {
+    val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
+    val keysListSerializer = ListSerializer(keySerializer)
+    val valuesListSerializer = ListSerializer(valueSerializer)
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            onNewValueRoute,
+            originalRepo.onNewValue,
+            PairSerializer(keySerializer, valueSerializer)
+        )
+
+        includeWebsocketHandling(
+            onValueRemovedRoute,
+            originalRepo.onValueRemoved,
+            keySerializer
+        )
+    }
+
+    post(setRoute) {
+        unifiedRouter.apply {
+            val toSet = uniload(
+                keyValueMapSerializer
+            )
+
+            unianswer(Unit.serializer(), originalRepo.set(toSet))
+        }
+    }
+
+    post(unsetRoute) {
+        unifiedRouter.apply {
+            val toUnset = uniload(keysListSerializer)
+
+            unianswer(Unit.serializer(), originalRepo.unset(toUnset))
+        }
+    }
+
+    post(unsetWithValuesRoute) {
+        unifiedRouter.apply {
+            val toUnset = uniload(valuesListSerializer)
+
+            unianswer(Unit.serializer(), originalRepo.unsetWithValues(toUnset))
+        }
+    }
+}
+
 fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
     originalRepo: WriteStandardKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
-) {
-    val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
-    val keysListSerializer = ListSerializer(keySerializer)
-    includeWebsocketHandling(
-        onNewValueRoute,
-        originalRepo.onNewValue,
-        PairSerializer(keySerializer, valueSerializer)
-    )
-
-    includeWebsocketHandling(
-        onValueRemovedRoute,
-        originalRepo.onValueRemoved,
-        keySerializer
-    )
-
-    post(setRoute) {
-        val toSet = call.uniload(
-            keyValueMapSerializer
-        )
-
-        call.unianswer(Unit.serializer(), originalRepo.set(toSet))
-    }
-
-    post(unsetRoute) {
-        val toUnset = call.uniload(keysListSerializer)
-
-        call.unianswer(Unit.serializer(), originalRepo.unset(toUnset))
-    }
-}
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureWriteStandardKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyKeyValueRepoRoutes.kt

@@ -1,6 +1,11 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.server.UnifiedRouter
+import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
 import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.route
 import kotlinx.serialization.KSerializer
@@ -9,10 +14,22 @@ fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
     baseSubpart: String,
     originalRepo: OneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
-    valueSealizer: KSerializer<Value>,
+    valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
-        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
-        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSealizer)
+        configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
+        configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, unifiedRouter)
     }
-}
+}
+
+fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
+    baseSubpart: String,
+    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyKeyValueRepoRoutes(
+    baseSubpart, originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
+)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyReadKeyValueRepoRoutes.kt

@@ -1,5 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
@@ -10,6 +12,7 @@ import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
 import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.get
 import kotlinx.serialization.KSerializer
@@ -18,89 +21,110 @@ import kotlinx.serialization.builtins.serializer
 fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
     originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
-    valueSealizer: KSerializer<Value>,
+    valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     val paginationKeyResult = PaginationResult.serializer(keySerializer)
-    val paginationValueResult = PaginationResult.serializer(valueSealizer)
+    val paginationValueResult = PaginationResult.serializer(valueSerializer)
 
     get(getRoute) {
-        val pagination = call.request.queryParameters.extractPagination
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
-        val reversed = call.decodeUrlQueryValue(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: false
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
+            val reversed = decodeUrlQueryValue(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: false
 
-        call.unianswer(
-            paginationValueResult,
-            originalRepo.get(key, pagination, reversed)
-        )
+            unianswer(
+                paginationValueResult,
+                originalRepo.get(key, pagination, reversed)
+            )
+        }
     }
 
     get(keysRoute) {
-        val pagination = call.request.queryParameters.extractPagination
-        val reversed = call.decodeUrlQueryValue(
-            reversedParameterName,
-            Boolean.serializer()
-        ) ?: false
-        val value: Value? = call.decodeUrlQueryValue(
-            valueParameterName,
-            valueSealizer
-        )
+        unifiedRouter.apply {
+            val pagination = call.request.queryParameters.extractPagination
+            val reversed = decodeUrlQueryValue(
+                reversedParameterName,
+                Boolean.serializer()
+            ) ?: false
+            val value: Value? = decodeUrlQueryValue(
+                valueParameterName,
+                valueSerializer
+            )
 
-        call.unianswer(
-            paginationKeyResult,
-            value ?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed)
-        )
+            unianswer(
+                paginationKeyResult,
+                value?.let { originalRepo.keys(value, pagination, reversed) } ?: originalRepo.keys(pagination, reversed)
+            )
+        }
     }
 
     get(containsByKeyRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key)
+            )
+        }
     }
 
     get(containsByKeyValueRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
-        val value = call.decodeUrlQueryValueOrSendError(
-            valueParameterName,
-            valueSealizer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
+            val value = decodeUrlQueryValueOrSendError(
+                valueParameterName,
+                valueSerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Boolean.serializer(),
-            originalRepo.contains(key, value)
-        )
+            unianswer(
+                Boolean.serializer(),
+                originalRepo.contains(key, value)
+            )
+        }
     }
 
     get(countByKeyRoute) {
-        val key = call.decodeUrlQueryValueOrSendError(
-            keyParameterName,
-            keySerializer
-        ) ?: return@get
+        unifiedRouter.apply {
+            val key = decodeUrlQueryValueOrSendError(
+                keyParameterName,
+                keySerializer
+            ) ?: return@get
 
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count(key)
-        )
+            unianswer(
+                Long.serializer(),
+                originalRepo.count(key)
+            )
+        }
     }
 
     get(countRoute) {
-        call.unianswer(
-            Long.serializer(),
-            originalRepo.count()
-        )
+        unifiedRouter.apply {
+            unianswer(
+                Long.serializer(),
+                originalRepo.count()
+            )
+        }
     }
-}
+}
+
+inline fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
+    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyReadKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyWriteKeyValueRepoRoutes.kt

@@ -1,9 +1,12 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
+import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
+import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.application.call
+import io.ktor.http.ContentType
 import io.ktor.routing.Route
 import io.ktor.routing.post
 import kotlinx.serialization.KSerializer
@@ -13,61 +16,78 @@ fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
     originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
+    unifiedRouter: UnifiedRouter
 ) {
     val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
     val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
 
-    includeWebsocketHandling(
-        onNewValueRoute,
-        originalRepo.onNewValue,
-        keyValueSerializer
-    )
-    includeWebsocketHandling(
-        onValueRemovedRoute,
-        originalRepo.onValueRemoved,
-        keyValueSerializer
-    )
-    includeWebsocketHandling(
-        onDataClearedRoute,
-        originalRepo.onDataCleared,
-        keySerializer
-    )
+    unifiedRouter.apply {
+        includeWebsocketHandling(
+            onNewValueRoute,
+            originalRepo.onNewValue,
+            keyValueSerializer
+        )
+        includeWebsocketHandling(
+            onValueRemovedRoute,
+            originalRepo.onValueRemoved,
+            keyValueSerializer
+        )
+        includeWebsocketHandling(
+            onDataClearedRoute,
+            originalRepo.onDataCleared,
+            keySerializer
+        )
+    }
 
     post(addRoute) {
-        val obj = call.uniload(keyValueMapSerializer)
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.add(obj)
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.add(obj)
+            )
+        }
     }
 
     post(removeRoute) {
-        val obj = call.uniload(
-            keyValueMapSerializer
-        )
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.remove(obj),
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.remove(obj),
+            )
+        }
     }
 
     post(clearRoute) {
-        val key = call.uniload(keySerializer)
+        unifiedRouter.apply {
+            val key = uniload(keySerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.clear(key),
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.clear(key),
+            )
+        }
     }
 
     post(setRoute) {
-        val obj = call.uniload(keyValueMapSerializer)
+        unifiedRouter.apply {
+            val obj = uniload(keyValueMapSerializer)
 
-        call.unianswer(
-            Unit.serializer(),
-            originalRepo.set(obj)
-        )
+            unianswer(
+                Unit.serializer(),
+                originalRepo.set(obj)
+            )
+        }
     }
-}
+}
+
+fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
+    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
+    keySerializer: KSerializer<Key>,
+    valueSerializer: KSerializer<Value>,
+    serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
+    serialFormatContentType: ContentType = standardKtorSerialFormatContentType
+) = configureOneToManyWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

selector/common/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
+            }
+        }
+    }
+}

selector/common/src/commonMain/kotlin/dev/inmo/micro_utils/selector/Selector.kt

@@ -0,0 +1,168 @@
+package dev.inmo.micro_utils.selector
+
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+
+/**
+ * Unified interface which can be used in any system which require some selection functionality
+ */
+interface Selector<T> {
+    val selectedItems: List<T>
+    val itemSelected: SharedFlow<T>
+    val itemUnselected: SharedFlow<T>
+
+    suspend fun toggleSelection(element: T)
+    suspend fun forceSelect(element: T)
+    suspend fun forceDeselect(element: T)
+    suspend fun clearSelection()
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline operator fun <T> Selector<T>.contains(element: T) = selectedItems.contains(element)
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T> Selector<T>.nothingSelected(): Boolean = selectedItems.isEmpty()
+suspend inline fun <T> Selector<T>.toggleSelection(elements: List<T>) = elements.forEach { toggleSelection(it) }
+suspend inline fun <T> Selector<T>.forceSelect(elements: List<T>) = elements.forEach { forceSelect(it) }
+suspend inline fun <T> Selector<T>.forceDeselect(elements: List<T>) = elements.forEach { forceDeselect(it) }
+suspend inline fun <T> Selector<T>.toggleSelection(firstElement: T, vararg elements: T) = toggleSelection(listOf(firstElement) + elements.toList())
+suspend inline fun <T> Selector<T>.forceSelect(firstElement: T, vararg elements: T) = forceSelect(listOf(firstElement) + elements.toList())
+suspend inline fun <T> Selector<T>.forceDeselect(firstElement: T, vararg elements: T) = forceDeselect(listOf(firstElement) + elements.toList())
+
+/**
+ * Realization of [Selector] with one or without selected element. This realization will always have empty
+ * [selectedItems] when nothing selected and one element in [selectedItems] when something selected. Contains
+ * [selectedItem] value for simple access to currently selected item.
+ *
+ * On calling of [toggleSelection] previous selection will be erased and [itemUnselected] will emit this element.
+ *
+ * @param safeChanges Set to false to disable using of [mutex] for synchronizing changes on [toggleSelection]
+ */
+class SingleSelector<T>(
+    selectedItem: T? = null,
+    safeChanges: Boolean = true
+) : Selector<T> {
+    var selectedItem: T? = selectedItem
+        private set
+    override val selectedItems: List<T>
+        get() = selectedItem ?.let { listOf(it) } ?: emptyList()
+
+    private val _itemSelected = MutableSharedFlow<T>()
+    override val itemSelected: SharedFlow<T> = _itemSelected.asSharedFlow()
+    private val _itemUnselected = MutableSharedFlow<T>()
+    override val itemUnselected: SharedFlow<T> = _itemUnselected.asSharedFlow()
+
+    private val mutex = if (safeChanges) {
+        Mutex()
+    } else {
+        null
+    }
+
+    override suspend fun forceDeselect(element: T) {
+        mutex ?.lock()
+        if (selectedItem == element) {
+            selectedItem = null
+            _itemUnselected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun forceSelect(element: T) {
+        mutex ?.lock()
+        if (selectedItem != element) {
+            selectedItem = element
+            _itemSelected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun toggleSelection(element: T) {
+        mutex ?.lock()
+        if (selectedItem == element) {
+            selectedItem = null
+            _itemUnselected.emit(element)
+        } else {
+            val previouslySelected = selectedItem
+            selectedItem = null
+            if (previouslySelected != null) {
+                _itemUnselected.emit(previouslySelected)
+            }
+            selectedItem = element
+            _itemSelected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun clearSelection() {
+        selectedItem ?.let { forceDeselect(it) }
+    }
+}
+
+/**
+ * Realization of [Selector] with multiple selected elements. On calling of [toggleSelection] this realization will select passed element OR deselect it if it is already in
+ * [selectedItems]
+ *
+ * @param safeChanges Set to false to disable using of [mutex] for synchronizing changes on [toggleSelection]
+ */
+class MultipleSelector<T>(
+    selectedItems: List<T> = emptyList(),
+    safeChanges: Boolean = true
+) : Selector<T> {
+    private val _selectedItems: MutableList<T> = selectedItems.toMutableList()
+    override val selectedItems: List<T> = _selectedItems
+
+    private val _itemSelected = MutableSharedFlow<T>()
+    override val itemSelected: SharedFlow<T> = _itemSelected.asSharedFlow()
+    private val _itemUnselected = MutableSharedFlow<T>()
+    override val itemUnselected: SharedFlow<T> = _itemUnselected.asSharedFlow()
+
+    private val mutex = if (safeChanges) {
+        Mutex()
+    } else {
+        null
+    }
+
+    override suspend fun forceDeselect(element: T) {
+        mutex ?.lock()
+        if (_selectedItems.remove(element)) {
+            _itemUnselected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun forceSelect(element: T) {
+        mutex ?.lock()
+        if (element !in _selectedItems && _selectedItems.add(element)) {
+            _itemSelected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun toggleSelection(element: T) {
+        mutex ?.lock()
+        if (_selectedItems.remove(element)) {
+            _itemUnselected.emit(element)
+        } else {
+            _selectedItems.add(element)
+            _itemSelected.emit(element)
+        }
+        mutex ?.unlock()
+    }
+
+    override suspend fun clearSelection() {
+        mutex ?.lock()
+        val preSelectedItems = _selectedItems.toList()
+        _selectedItems.clear()
+        preSelectedItems.forEach { _itemUnselected.emit(it) }
+        mutex ?.unlock()
+    }
+}
+
+@Suppress("FunctionName", "NOTHING_TO_INLINE")
+inline fun <T> Selector(
+    multiple: Boolean,
+    safeChanges: Boolean = true
+): Selector<T> = if (multiple) {
+    MultipleSelector(safeChanges = safeChanges)
+} else {
+    SingleSelector(safeChanges = safeChanges)
+}

selector/common/src/commonMain/kotlin/dev/inmo/micro_utils/selector/SelectorItemsFlow.kt

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.selector
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.*
+
+/**
+ * @return Returned [SharedFlow] will emit true when [element] has been selected in [this] [Selector] and will emit
+ * false when this [element] was deselected
+ *
+ * @see [Selector]
+ * @see [Selector.itemSelected]
+ * @see [Selector.itemUnselected]
+ */
+fun <T> Selector<T>.itemSelectionFlow(element: T, scope: CoroutineScope): SharedFlow<Boolean> = MutableSharedFlow<Boolean>().apply {
+    itemSelected.onEach { if (it == element) emit(true) }.launchIn(scope)
+    itemUnselected.onEach { if (it == element) emit(false) }.launchIn(scope)
+}.asSharedFlow()

selector/common/src/main/AndroidManifest.xml

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

settings.gradle

@@ -2,6 +2,7 @@ rootProject.name='micro_utils'
 
 String[] includes = [
     ":common",
+    ":selector:common",
     ":pagination:common",
     ":pagination:exposed",
     ":pagination:ktor:common",
@@ -18,6 +19,8 @@ String[] includes = [
     ":ktor:client",
     ":coroutines",
     ":android:recyclerview",
+    ":android:alerts:common",
+    ":android:alerts:recyclerview",
 
     ":dokka"
 ]